@tool-bridge/server 0.1.0 → 0.3.0

package/dist/brave_search-3DDR2MMB.js

@@ -0,0 +1,322 @@
+import {
+  createProviderPlugin,
+  guardedFetch,
+  requireApiKey,
+  upstreamError
+} from "./chunk-CSJEZHQO.js";
+import "./chunk-K7FVSFUX.js";
+import {
+  TBError,
+  external_exports
+} from "./chunk-JLTYA2B3.js";
+import "./chunk-MLKGABMK.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 text(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function nullableRecord(value) {
+  return value === null ? null : record(value);
+}
+function requireRecord(value, label) {
+  const result = record(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 compact(input) {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
+}
+function searchTerm(value) {
+  const term = text(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 text(value);
+  const items = value.map((item) => text(item)).filter((item) => item !== void 0);
+  return items.length > 0 ? items : void 0;
+}
+function buildUrl(path, query) {
+  const url = new URL(`${API_BASE}${path}`);
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) url.searchParams.append(key, item);
+      continue;
+    }
+    url.searchParams.set(key, String(value));
+  }
+  return url.toString();
+}
+function braveSearchError(status, payload) {
+  const error = record(record(payload)?.error);
+  const message = text(error?.detail) ?? text(error?.code) ?? `Brave Search \u8FD4\u56DE HTTP ${status}`;
+  const code = text(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);
+}
+async function request(ctx, path, query) {
+  const response = await guardedFetch(buildUrl(path, query), {
+    method: "GET",
+    headers: {
+      "accept": "application/json",
+      "x-subscription-token": requireApiKey(ctx, SERVICE)
+    }
+  });
+  const body = await response.text();
+  let payload = null;
+  if (body !== "") {
+    try {
+      payload = JSON.parse(body);
+    } catch {
+      if (response.ok) {
+        throw new TBError("unavailable", "Brave Search \u8FD4\u56DE\u4E86\u975E JSON \u54CD\u5E94", { retryable: true });
+      }
+    }
+  }
+  if (!response.ok) throw braveSearchError(response.status, payload);
+  return payload;
+}
+function normalizeWebSearch(payload) {
+  const result = requireRecord(payload, "Brave Search \u54CD\u5E94");
+  return compact({
+    type: text(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 compact({
+    type: text(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: text(input.search_lang),
+    ui_lang: text(input.ui_lang),
+    country: text(input.country),
+    safesearch: text(input.safesearch),
+    count: input.count,
+    offset: input.offset,
+    spellcheck: input.spellcheck,
+    freshness: text(input.freshness),
+    result_filter: text(input.result_filter),
+    extra_snippets: input.extra_snippets,
+    goggles: goggles(input.goggles),
+    text_decorations: input.text_decorations,
+    units: text(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: text(input.search_lang),
+    ui_lang: text(input.ui_lang),
+    country: text(input.country),
+    safesearch: text(input.safesearch),
+    count: input.count,
+    offset: input.offset,
+    spellcheck: input.spellcheck,
+    freshness: text(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: text(input.search_lang),
+    ui_lang: text(input.ui_lang),
+    country: text(input.country),
+    safesearch: text(input.safesearch),
+    count: input.count,
+    offset: input.offset,
+    spellcheck: input.spellcheck,
+    freshness: text(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: text(input.search_lang),
+    country: text(input.country),
+    safesearch: text(input.safesearch),
+    count: input.count,
+    spellcheck: input.spellcheck
+  });
+  return normalizeCollection(payload, true);
+}
+
+// ../plugins/src/brave_search/schema.ts
+var webSearchInput = external_exports.strictObject({
+  q: external_exports.string().min(1).max(400).describe("The user's search query term. Maximum of 400 characters."),
+  search_lang: external_exports.string().min(2).describe("The preferred search result language code.").optional(),
+  ui_lang: external_exports.string().min(2).describe("The preferred user interface language for response formatting.").optional(),
+  country: external_exports.string().min(2).max(3).describe("The two-letter country code for result localization, or ALL for worldwide results.").optional(),
+  safesearch: external_exports.enum(["off", "moderate", "strict"]).describe("Filters adult content from web results.").optional(),
+  count: external_exports.int().min(1).max(20).describe("The maximum number of web results to return.").optional(),
+  offset: external_exports.int().min(0).max(9).describe("The zero-based results page offset used for pagination.").optional(),
+  spellcheck: external_exports.boolean().describe("Whether Brave Search should spellcheck the query before searching.").optional(),
+  freshness: external_exports.union([external_exports.enum(["pd", "pw", "pm", "py"]).describe("A predefined freshness window such as past day or past year."), external_exports.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: external_exports.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: external_exports.boolean().describe("Whether Brave Search should return extra alternate snippets.").optional(),
+  goggles: external_exports.union([external_exports.string().min(1).describe("One goggle URL or inline definition."), external_exports.array(external_exports.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: external_exports.boolean().describe("Whether display strings should include decoration markers such as highlights.").optional(),
+  units: external_exports.enum(["metric", "imperial"]).describe("The measurement units used for localized results.").optional(),
+  operators: external_exports.boolean().describe("Whether Brave Search should apply search operators.").optional(),
+  include_fetch_metadata: external_exports.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 = external_exports.strictObject({
+  type: external_exports.string().describe("The Brave Search response type."),
+  query: external_exports.looseObject({}).describe("Query metadata returned by Brave Search.").nullable().optional(),
+  web: external_exports.looseObject({}).describe("Web result payload returned by Brave Search.").nullable().optional(),
+  news: external_exports.looseObject({}).describe("News result payload returned by Brave Search.").nullable().optional(),
+  videos: external_exports.looseObject({}).describe("Video result payload returned by Brave Search.").nullable().optional(),
+  locations: external_exports.looseObject({}).describe("Location result payload returned by Brave Search.").nullable().optional(),
+  discussions: external_exports.looseObject({}).describe("Discussion clusters returned by Brave Search.").nullable().optional(),
+  faq: external_exports.looseObject({}).describe("Frequently asked questions returned by Brave Search.").nullable().optional(),
+  infobox: external_exports.looseObject({}).describe("Infobox payload returned by Brave Search.").nullable().optional(),
+  mixed: external_exports.looseObject({}).describe("Mixed ranking payload returned by Brave Search.").nullable().optional(),
+  summarizer: external_exports.looseObject({}).describe("Summary metadata returned by Brave Search.").nullable().optional(),
+  rich: external_exports.looseObject({}).describe("Rich result callback payload returned by Brave Search.").nullable().optional()
+}).describe("A normalized Brave Search web search response.");
+var newsSearchInput = external_exports.strictObject({
+  q: external_exports.string().min(1).max(400).describe("The user's search query term. Maximum of 400 characters."),
+  search_lang: external_exports.string().min(2).describe("The preferred search result language code.").optional(),
+  ui_lang: external_exports.string().min(2).describe("The preferred user interface language for response formatting.").optional(),
+  country: external_exports.string().min(2).max(3).describe("The two-letter country code for result localization, or ALL for worldwide results.").optional(),
+  safesearch: external_exports.enum(["off", "moderate", "strict"]).describe("Filters adult content from news results.").optional(),
+  count: external_exports.int().min(1).max(50).describe("The maximum number of results to return.").optional(),
+  offset: external_exports.int().min(0).max(9).describe("The zero-based results page offset used for pagination.").optional(),
+  spellcheck: external_exports.boolean().describe("Whether Brave Search should spellcheck the query before searching.").optional(),
+  freshness: external_exports.union([external_exports.enum(["pd", "pw", "pm", "py"]).describe("A predefined freshness window such as past day or past year."), external_exports.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: external_exports.boolean().describe("Whether Brave Search should return extra alternate snippets.").optional(),
+  goggles: external_exports.union([external_exports.string().min(1).describe("One goggle URL or inline definition."), external_exports.array(external_exports.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: external_exports.boolean().describe("Whether Brave Search should apply search operators.").optional(),
+  include_fetch_metadata: external_exports.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 = external_exports.strictObject({
+  type: external_exports.string().describe("The Brave Search response type."),
+  query: external_exports.looseObject({}).describe("Query metadata returned by Brave Search.").nullable().optional(),
+  results: external_exports.array(external_exports.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 = external_exports.strictObject({
+  q: external_exports.string().min(1).max(400).describe("The user's search query term. Maximum of 400 characters."),
+  search_lang: external_exports.string().min(2).describe("The preferred search result language code.").optional(),
+  ui_lang: external_exports.string().min(2).describe("The preferred user interface language for response formatting.").optional(),
+  country: external_exports.string().min(2).max(3).describe("The two-letter country code for result localization, or ALL for worldwide results.").optional(),
+  safesearch: external_exports.enum(["off", "moderate", "strict"]).describe("Filters adult content from video results.").optional(),
+  count: external_exports.int().min(1).max(50).describe("The maximum number of results to return.").optional(),
+  offset: external_exports.int().min(0).max(9).describe("The zero-based results page offset used for pagination.").optional(),
+  spellcheck: external_exports.boolean().describe("Whether Brave Search should spellcheck the query before searching.").optional(),
+  freshness: external_exports.union([external_exports.enum(["pd", "pw", "pm", "py"]).describe("A predefined freshness window such as past day or past year."), external_exports.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: external_exports.boolean().describe("Whether Brave Search should apply search operators.").optional(),
+  include_fetch_metadata: external_exports.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 = external_exports.strictObject({
+  type: external_exports.string().describe("The Brave Search response type."),
+  query: external_exports.looseObject({}).describe("Query metadata returned by Brave Search.").nullable().optional(),
+  results: external_exports.array(external_exports.looseObject({}).describe("One video result item returned by Brave Search.")).describe("The list of video results returned by Brave Search.").optional(),
+  extra: external_exports.looseObject({}).describe("Additional metadata returned with the video results.").nullable().optional()
+}).describe("A normalized Brave Search video response.");
+var imageSearchInput = external_exports.strictObject({
+  q: external_exports.string().min(1).max(400).describe("The user's search query term. Maximum of 400 characters."),
+  search_lang: external_exports.string().min(2).describe("The preferred search result language code.").optional(),
+  country: external_exports.string().min(2).max(3).describe("The two-letter country code for result localization, or ALL for worldwide results.").optional(),
+  safesearch: external_exports.enum(["off", "strict"]).describe("Filters adult content from image results.").optional(),
+  count: external_exports.int().min(1).max(200).describe("The maximum number of image results to return.").optional(),
+  spellcheck: external_exports.boolean().describe("Whether Brave Search should spellcheck the query before searching.").optional()
+}).describe("Input parameters for a Brave Search image request.");
+var imageSearchOutput = external_exports.strictObject({
+  type: external_exports.string().describe("The Brave Search response type."),
+  query: external_exports.looseObject({}).describe("Query metadata returned by Brave Search.").nullable().optional(),
+  results: external_exports.array(external_exports.looseObject({}).describe("One image result item returned by Brave Search.")).describe("The list of image results returned by Brave Search.").optional(),
+  extra: external_exports.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: external_exports.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: external_exports.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: external_exports.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: external_exports.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-CSJEZHQO.js

@@ -0,0 +1,252 @@
+import {
+  createPlugin
+} from "./chunk-K7FVSFUX.js";
+import {
+  TBError
+} from "./chunk-JLTYA2B3.js";
+
+// ../plugins/src/_runtime/plugin.ts
+function requireApiKey(ctx, service) {
+  const key = ctx.upstreamAuth;
+  if (key === void 0 || key === "") {
+    throw new TBError(
+      "unavailable",
+      `${service} \u9700\u8981 API key:\u7ED9\u6302\u8F7D\u8282\u70B9\u914D config.authRef \u6307\u5411\u5DF2\u5B58\u5165 system/secret \u7684\u51ED\u8BC1`
+    );
+  }
+  return key;
+}
+function requireCredential(ctx, service, field) {
+  const values = ctx.credentials;
+  if (values === void 0) {
+    throw new TBError(
+      "unavailable",
+      `${service} \u9700\u8981\u591A\u5B57\u6BB5\u51ED\u8BC1:\u7ED9\u6302\u8F7D\u8282\u70B9\u914D config.authRef \u6307\u5411\u5DF2\u5B58\u5165 system/secret \u7684\u51ED\u8BC1(\u7528 \`tb secret set <name> --field ...\` \u5199\u5165)`
+    );
+  }
+  const value = values[field];
+  if (value === void 0 || value === "") {
+    throw new TBError("internal", `${service} \u7684\u51ED\u8BC1\u5B57\u6BB5 '${field}' \u672A\u5728 credentialFields \u91CC\u58F0\u660E`);
+  }
+  return value;
+}
+function createProviderPlugin(input) {
+  const names = Object.keys(input.actions);
+  const handlerNames = Object.keys(input.handlers);
+  const missing = names.filter((name) => !handlerNames.includes(name));
+  const extra = handlerNames.filter((name) => !names.includes(name));
+  if (missing.length > 0 || extra.length > 0) {
+    throw new Error(
+      `action \u8868\u4E0E handler \u8868\u4E0D\u543B\u5408:\u7F3A handler [${missing.join(", ")}];\u591A\u4F59 handler [${extra.join(", ")}]`
+    );
+  }
+  const plugin = createPlugin({ token: (env) => env.PLUGIN_TOKEN });
+  const tools = plugin.tools(input.exportId ?? "actions", { description: input.description });
+  if (input.oauth !== void 0) tools.oauth(input.oauth);
+  if (input.credentialFields !== void 0) tools.credentials(input.credentialFields);
+  for (const name of names) {
+    tools.register(name, input.actions[name], (args, ctx) => input.handlers[name](args, {
+      upstreamAuth: ctx.upstreamAuth,
+      credentials: ctx.credentials,
+      config: ctx.mountConfig
+    }));
+  }
+  if (input.credentialProbe !== void 0) {
+    const effect = input.actions[input.credentialProbe]?.effect;
+    if (effect !== "read") {
+      throw new Error(
+        `credentialProbe '${input.credentialProbe}' \u7684 effect \u662F '${effect ?? "\u672A\u58F0\u660E"}', \u63A2\u9488\u5FC5\u987B\u662F read \u2014\u2014 \u6302\u8F7D\u65F6\u4F1A\u771F\u5B9E\u8C03\u7528\u5B83`
+      );
+    }
+    tools.probeCredentialWith(input.credentialProbe);
+  }
+  return plugin;
+}
+
+// ../plugins/src/_runtime/upstreamError.ts
+function upstreamError(status, message) {
+  if (status === 401) {
+    return new TBError("permission_denied", message, { httpStatus: 401 });
+  }
+  if (status === 403) return new TBError("permission_denied", message);
+  if (status === 404) return new TBError("not_found", message);
+  if (status === 409) return new TBError("conflict", message);
+  if (status === 429) return new TBError("rate_limited", message, { retryable: true });
+  if (status >= 500) return new TBError("unavailable", message, { retryable: true });
+  return new TBError("invalid_argument", message);
+}
+
+// ../plugins/src/_runtime/ipPolicy.ts
+function parseIpv4(value) {
+  const parts = value.split(".");
+  if (parts.length !== 4) return void 0;
+  let result = 0;
+  for (const part of parts) {
+    if (!/^\d{1,3}$/.test(part) || part.length > 1 && part.startsWith("0")) return void 0;
+    const octet = Number(part);
+    if (octet > 255) return void 0;
+    result = result << 8 | octet;
+  }
+  return result >>> 0;
+}
+function parseIpv6(value) {
+  let text = value;
+  if (text.startsWith("[") && text.endsWith("]")) text = text.slice(1, -1);
+  const zone = text.indexOf("%");
+  if (zone !== -1) text = text.slice(0, zone);
+  if (!text.includes(":")) return void 0;
+  const halves = text.split("::");
+  if (halves.length > 2) return void 0;
+  const expand = (part) => {
+    if (part === "") return [];
+    const groups2 = [];
+    const chunks = part.split(":");
+    for (let i = 0; i < chunks.length; i += 1) {
+      const chunk = chunks[i];
+      if (i === chunks.length - 1 && chunk.includes(".")) {
+        const v4 = parseIpv4(chunk);
+        if (v4 === void 0) return void 0;
+        groups2.push(v4 >>> 16 & 65535, v4 & 65535);
+        continue;
+      }
+      if (!/^[0-9a-fA-F]{1,4}$/.test(chunk)) return void 0;
+      groups2.push(Number.parseInt(chunk, 16));
+    }
+    return groups2;
+  };
+  const head = expand(halves[0] ?? "");
+  const tail = halves.length === 2 ? expand(halves[1] ?? "") : [];
+  if (head === void 0 || tail === void 0) return void 0;
+  const missing = 8 - head.length - tail.length;
+  if (halves.length === 2 ? missing < 0 : missing !== 0) return void 0;
+  const groups = [...head, ...Array.from({ length: halves.length === 2 ? missing : 0 }, () => 0), ...tail];
+  if (groups.length !== 8) return void 0;
+  const bytes = new Uint8Array(16);
+  groups.forEach((group, i) => {
+    bytes[i * 2] = group >>> 8 & 255;
+    bytes[i * 2 + 1] = group & 255;
+  });
+  return bytes;
+}
+function classifyIpv4(value) {
+  const a = value >>> 24 & 255;
+  const b = value >>> 16 & 255;
+  const c = value >>> 8 & 255;
+  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) {
+    const v4 = (bytes[12] << 24 | bytes[13] << 16 | bytes[14] << 8 | bytes[15]) >>> 0;
+    return classifyIpv4(v4);
+  }
+  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 parseIpv4(value) !== void 0 || parseIpv6(value) !== void 0;
+}
+function classifyIpAddress(address) {
+  const v4 = parseIpv4(address);
+  if (v4 !== void 0) return classifyIpv4(v4);
+  const v6 = parseIpv6(address);
+  if (v6 !== void 0) return classifyIpv6(v6);
+  return "blocked";
+}
+
+// ../plugins/src/_runtime/guardedFetch.ts
+var MAX_REDIRECTS = 5;
+var CROSS_ORIGIN_STRIPPED_HEADERS = [
+  "authorization",
+  "cookie",
+  "proxy-authorization"
+  // 各家自定义的密钥头没有统一命名,凡是名字里带 key/token/secret 的一律剥掉:
+  // 宁可让跨源跳转少带一个无关头,也不能漏带走一个凭证。
+];
+function looksLikeCredentialHeader(name) {
+  return /(?:^|-)(?:api[-_]?key|key|token|secret|auth)(?:$|-)/i.test(name);
+}
+function stripCredentials(headers) {
+  const next = new Headers(headers);
+  for (const [name] of headers) {
+    if (CROSS_ORIGIN_STRIPPED_HEADERS.includes(name.toLowerCase()) || looksLikeCredentialHeader(name)) {
+      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 maxRedirects = options.maxRedirects ?? MAX_REDIRECTS;
+  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, { 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 headers = url.origin === previousOrigin ? request.headers : stripCredentials(request.headers);
+      const downgrade = response.status === 303 || (response.status === 301 || response.status === 302) && request.method !== "GET";
+      request = downgrade ? new Request(url, { method: "GET", headers, redirect: "manual" }) : new Request(url, { ...request, headers, redirect: "manual" });
+    }
+  };
+}
+var guardedFetch = createGuardedFetch();
+
+export {
+  requireApiKey,
+  requireCredential,
+  createProviderPlugin,
+  upstreamError,
+  assertPublicHttpUrl,
+  guardedFetch
+};