@opengeni/runtime 0.11.0 → 0.13.3

package/dist/chunk-SSB7VOLE.js

@@ -0,0 +1,301 @@
+// src/mcp-network.ts
+import {
+  isNonPublicAddress,
+  pinnedFetch,
+  resolvePinnedDestination
+} from "@opengeni/network";
+import { undiciFetch } from "@opengeni/network";
+var MCP_MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
+var MCP_MAX_INBOUND_REQUEST_BYTES = 1024 * 1024;
+var MCP_MAX_TOOL_DEFINITION_BYTES = 128 * 1024;
+var MCP_MAX_TOOL_LIST_BYTES = 4 * 1024 * 1024;
+var MCP_MAX_TOOL_LIST_ENTRIES = 1e3;
+var MCP_MAX_TOOL_RESULT_BYTES = 1024 * 1024;
+var MCP_MAX_TOOL_SEARCH_DISCLOSURE_BYTES = 256 * 1024;
+var MCP_MAX_SELECTED_SERVERS = 64;
+var MCP_MAX_CONCURRENT_SERVER_OPERATIONS = 8;
+var MCP_DEFAULT_OUTER_CONNECT_TIMEOUT_MS = 1e4;
+var MCP_MAX_AGGREGATE_TOOL_LIST_ENTRIES = 4096;
+var MCP_MAX_AGGREGATE_TOOL_LIST_BYTES = 16 * 1024 * 1024;
+var MCP_MAX_TOOL_SEARCH_SOURCES = 64;
+var MCP_MAX_TOOL_SEARCH_SOURCE_LABEL_LENGTH = 120;
+var MCP_MAX_TOOL_SEARCH_DESCRIPTION_BYTES = 16 * 1024;
+var McpPayloadTooLargeError = class extends Error {
+  constructor(label, actualBytes, maxBytes) {
+    super(`${label} exceeds the ${maxBytes}-byte safety limit`);
+    this.label = label;
+    this.actualBytes = actualBytes;
+    this.maxBytes = maxBytes;
+    this.name = "McpPayloadTooLargeError";
+  }
+};
+function mcpSerializedSizeBytes(value) {
+  let serialized;
+  try {
+    serialized = JSON.stringify(value) ?? "null";
+  } catch {
+    throw new Error("MCP payload is not JSON serializable");
+  }
+  return Buffer.byteLength(serialized);
+}
+function assertMcpPayloadWithinBytes(value, maxBytes, label) {
+  const actualBytes = mcpSerializedSizeBytes(value);
+  if (actualBytes > maxBytes) {
+    throw new McpPayloadTooLargeError(label, actualBytes, maxBytes);
+  }
+}
+function assertMcpToolListWithinBounds(tools) {
+  if (tools.length > MCP_MAX_TOOL_LIST_ENTRIES) {
+    throw new McpPayloadTooLargeError("MCP tool list", tools.length, MCP_MAX_TOOL_LIST_ENTRIES);
+  }
+  for (const tool of tools) {
+    const toolBytes = mcpSerializedSizeBytes(tool);
+    if (toolBytes > MCP_MAX_TOOL_DEFINITION_BYTES) {
+      throw new McpPayloadTooLargeError(
+        "MCP tool definition",
+        toolBytes,
+        MCP_MAX_TOOL_DEFINITION_BYTES
+      );
+    }
+  }
+  const totalBytes = mcpSerializedSizeBytes(tools);
+  if (totalBytes > MCP_MAX_TOOL_LIST_BYTES) {
+    throw new McpPayloadTooLargeError("MCP tool list", totalBytes, MCP_MAX_TOOL_LIST_BYTES);
+  }
+  return tools;
+}
+function assertMcpServerSelectionWithinBounds(servers) {
+  if (servers.length > MCP_MAX_SELECTED_SERVERS) {
+    throw new McpPayloadTooLargeError(
+      "selected MCP server count",
+      servers.length,
+      MCP_MAX_SELECTED_SERVERS
+    );
+  }
+  return servers;
+}
+function mcpOuterConnectTimeoutMs(configuredTimeouts) {
+  return Math.max(
+    MCP_DEFAULT_OUTER_CONNECT_TIMEOUT_MS,
+    ...configuredTimeouts.flatMap((timeoutMs) => timeoutMs === void 0 ? [] : [timeoutMs])
+  );
+}
+var McpAggregateToolListBudget = class {
+  constructor(label = "aggregate MCP tool list", maxEntries = MCP_MAX_AGGREGATE_TOOL_LIST_ENTRIES, maxBytes = MCP_MAX_AGGREGATE_TOOL_LIST_BYTES) {
+    this.label = label;
+    this.maxEntries = maxEntries;
+    this.maxBytes = maxBytes;
+  }
+  contributions = /* @__PURE__ */ new Map();
+  totalEntries = 0;
+  totalBytes = 0;
+  replace(sourceId, tools) {
+    assertMcpToolListWithinBounds(tools);
+    const contribution = {
+      entries: tools.length,
+      // Conservatively account each server as its complete serialized array.
+      // Summing these arrays slightly over-counts the brackets relative to one
+      // flattened array, which is intentional for a fail-closed hard ceiling.
+      bytes: mcpSerializedSizeBytes(tools)
+    };
+    const previous = this.contributions.get(sourceId) ?? { entries: 0, bytes: 0 };
+    const nextEntries = this.totalEntries - previous.entries + contribution.entries;
+    if (nextEntries > this.maxEntries) {
+      throw new McpPayloadTooLargeError(this.label, nextEntries, this.maxEntries);
+    }
+    const nextBytes = this.totalBytes - previous.bytes + contribution.bytes;
+    if (nextBytes > this.maxBytes) {
+      throw new McpPayloadTooLargeError(this.label, nextBytes, this.maxBytes);
+    }
+    this.contributions.set(sourceId, contribution);
+    this.totalEntries = nextEntries;
+    this.totalBytes = nextBytes;
+    return tools;
+  }
+  remove(sourceId) {
+    const previous = this.contributions.get(sourceId);
+    if (!previous) return;
+    this.contributions.delete(sourceId);
+    this.totalEntries -= previous.entries;
+    this.totalBytes -= previous.bytes;
+  }
+  snapshot() {
+    return { entries: this.totalEntries, bytes: this.totalBytes };
+  }
+};
+async function boundedParallelMap(values, concurrency, mapper) {
+  if (!Number.isInteger(concurrency) || concurrency < 1) {
+    throw new Error("bounded parallel map concurrency must be a positive integer");
+  }
+  if (values.length === 0) return [];
+  const results = new Array(values.length);
+  const errors = [];
+  let nextIndex = 0;
+  let stopped = false;
+  const worker = async () => {
+    while (!stopped) {
+      const index = nextIndex;
+      if (index >= values.length) return;
+      nextIndex += 1;
+      try {
+        results[index] = await mapper(values[index], index);
+      } catch (error) {
+        errors.push({ index, error });
+        stopped = true;
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, () => worker()));
+  if (errors.length > 0) {
+    errors.sort((left, right) => left.index - right.index);
+    throw errors[0].error;
+  }
+  return results;
+}
+function guardedMcpFetch(settings, fetchImpl, options = {}) {
+  return async (input, init) => {
+    const response = await pinnedFetch(input, init, settings, {
+      fetchImpl,
+      ...options.dnsLookup ? { dnsLookup: options.dnsLookup } : {},
+      label: "MCP endpoint",
+      requireHttpsOutsideLocalTest: options.requireHttpsOutsideLocalTest ?? true
+    });
+    return boundMcpResponseBody(response, options.maxResponseBytes ?? MCP_MAX_RESPONSE_BYTES);
+  };
+}
+function boundMcpResponseBody(response, maxBytes) {
+  const declaredLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > maxBytes) {
+    void response.body?.cancel().catch(() => void 0);
+    throw new McpPayloadTooLargeError("MCP response", declaredLength, maxBytes);
+  }
+  if (!response.body) {
+    return response;
+  }
+  const reader = response.body.getReader();
+  let receivedBytes = 0;
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const chunk = await reader.read();
+        if (chunk.done) {
+          controller.close();
+          return;
+        }
+        receivedBytes += chunk.value.byteLength;
+        if (receivedBytes > maxBytes) {
+          await reader.cancel().catch(() => void 0);
+          controller.error(new McpPayloadTooLargeError("MCP response", receivedBytes, maxBytes));
+          return;
+        }
+        controller.enqueue(chunk.value);
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    async cancel(reason) {
+      await reader.cancel(reason).catch(() => void 0);
+    }
+  });
+  const bounded = new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+  Object.defineProperties(bounded, {
+    redirected: { value: response.redirected },
+    type: { value: response.type },
+    url: { value: response.url }
+  });
+  return bounded;
+}
+async function cancelMcpResponseBody(response) {
+  await response.body?.cancel().catch(() => void 0);
+}
+async function boundedMcpRequest(request, maxBytes = MCP_MAX_INBOUND_REQUEST_BYTES) {
+  const declared = request.headers.get("content-length");
+  if (declared !== null) {
+    const normalized = declared.trim();
+    if (!/^\d+$/.test(normalized)) {
+      await request.body?.cancel().catch(() => void 0);
+      throw new McpPayloadTooLargeError("MCP request", 0, maxBytes);
+    }
+    const declaredBytes = Number(normalized);
+    if (!Number.isSafeInteger(declaredBytes) || declaredBytes > maxBytes) {
+      await request.body?.cancel().catch(() => void 0);
+      throw new McpPayloadTooLargeError("MCP request", declaredBytes, maxBytes);
+    }
+  }
+  if (!request.body) {
+    return request;
+  }
+  const reader = request.body.getReader();
+  const chunks = [];
+  let receivedBytes = 0;
+  try {
+    for (; ; ) {
+      const result = await reader.read();
+      if (result.done) break;
+      receivedBytes += result.value.byteLength;
+      if (receivedBytes > maxBytes) {
+        await reader.cancel().catch(() => void 0);
+        throw new McpPayloadTooLargeError("MCP request", receivedBytes, maxBytes);
+      }
+      chunks.push(result.value);
+    }
+  } catch (error) {
+    await reader.cancel().catch(() => void 0);
+    throw error;
+  } finally {
+    reader.releaseLock();
+  }
+  const body = new Uint8Array(receivedBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new Request(request, { body, headers: request.headers });
+}
+async function assertMcpDestinationAllowed(rawUrl, settings, options = {}) {
+  await resolvePinnedDestination(rawUrl, settings, {
+    ...options.dnsLookup ? { dnsLookup: options.dnsLookup } : {},
+    label: "MCP endpoint",
+    requireHttpsOutsideLocalTest: true
+  });
+}
+var isNonPublicMcpAddress = isNonPublicAddress;
+
+export {
+  MCP_MAX_RESPONSE_BYTES,
+  MCP_MAX_INBOUND_REQUEST_BYTES,
+  MCP_MAX_TOOL_DEFINITION_BYTES,
+  MCP_MAX_TOOL_LIST_BYTES,
+  MCP_MAX_TOOL_LIST_ENTRIES,
+  MCP_MAX_TOOL_RESULT_BYTES,
+  MCP_MAX_TOOL_SEARCH_DISCLOSURE_BYTES,
+  MCP_MAX_SELECTED_SERVERS,
+  MCP_MAX_CONCURRENT_SERVER_OPERATIONS,
+  MCP_DEFAULT_OUTER_CONNECT_TIMEOUT_MS,
+  MCP_MAX_AGGREGATE_TOOL_LIST_ENTRIES,
+  MCP_MAX_AGGREGATE_TOOL_LIST_BYTES,
+  MCP_MAX_TOOL_SEARCH_SOURCES,
+  MCP_MAX_TOOL_SEARCH_SOURCE_LABEL_LENGTH,
+  MCP_MAX_TOOL_SEARCH_DESCRIPTION_BYTES,
+  McpPayloadTooLargeError,
+  mcpSerializedSizeBytes,
+  assertMcpPayloadWithinBytes,
+  assertMcpToolListWithinBounds,
+  assertMcpServerSelectionWithinBounds,
+  mcpOuterConnectTimeoutMs,
+  McpAggregateToolListBudget,
+  boundedParallelMap,
+  guardedMcpFetch,
+  boundMcpResponseBody,
+  cancelMcpResponseBody,
+  boundedMcpRequest,
+  assertMcpDestinationAllowed,
+  isNonPublicMcpAddress,
+  undiciFetch
+};
+//# sourceMappingURL=chunk-SSB7VOLE.js.map

package/dist/chunk-SSB7VOLE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/mcp-network.ts"],"sourcesContent":["import type { Settings } from \"@opengeni/config\";\nimport {\n  isNonPublicAddress,\n  pinnedFetch,\n  resolvePinnedDestination,\n  type DnsLookup,\n  type FetchLike,\n} from \"@opengeni/network\";\n\nexport { undiciFetch } from \"@opengeni/network\";\n\nexport const MCP_MAX_RESPONSE_BYTES = 8 * 1024 * 1024;\nexport const MCP_MAX_INBOUND_REQUEST_BYTES = 1024 * 1024;\nexport const MCP_MAX_TOOL_DEFINITION_BYTES = 128 * 1024;\nexport const MCP_MAX_TOOL_LIST_BYTES = 4 * 1024 * 1024;\nexport const MCP_MAX_TOOL_LIST_ENTRIES = 1_000;\nexport const MCP_MAX_TOOL_RESULT_BYTES = 1024 * 1024;\nexport const MCP_MAX_TOOL_SEARCH_DISCLOSURE_BYTES = 256 * 1024;\nexport const MCP_MAX_SELECTED_SERVERS = 64;\nexport const MCP_MAX_CONCURRENT_SERVER_OPERATIONS = 8;\n// @openai/agents has a separate lifecycle fence around MCPServer.connect().\n// It defaults to 10 seconds and can otherwise preempt a larger per-server\n// transport timeout before that server finishes its own handshake.\nexport const MCP_DEFAULT_OUTER_CONNECT_TIMEOUT_MS = 10_000;\nexport const MCP_MAX_AGGREGATE_TOOL_LIST_ENTRIES = 4_096;\nexport const MCP_MAX_AGGREGATE_TOOL_LIST_BYTES = 16 * 1024 * 1024;\nexport const MCP_MAX_TOOL_SEARCH_SOURCES = 64;\nexport const MCP_MAX_TOOL_SEARCH_SOURCE_LABEL_LENGTH = 120;\nexport const MCP_MAX_TOOL_SEARCH_DESCRIPTION_BYTES = 16 * 1024;\n\nexport class McpPayloadTooLargeError extends Error {\n  constructor(\n    readonly label: string,\n    readonly actualBytes: number,\n    readonly maxBytes: number,\n  ) {\n    super(`${label} exceeds the ${maxBytes}-byte safety limit`);\n    this.name = \"McpPayloadTooLargeError\";\n  }\n}\n\nexport function mcpSerializedSizeBytes(value: unknown): number {\n  let serialized: string;\n  try {\n    serialized = JSON.stringify(value) ?? \"null\";\n  } catch {\n    throw new Error(\"MCP payload is not JSON serializable\");\n  }\n  return Buffer.byteLength(serialized);\n}\n\nexport function assertMcpPayloadWithinBytes(value: unknown, maxBytes: number, label: string): void {\n  const actualBytes = mcpSerializedSizeBytes(value);\n  if (actualBytes > maxBytes) {\n    throw new McpPayloadTooLargeError(label, actualBytes, maxBytes);\n  }\n}\n\nexport function assertMcpToolListWithinBounds<T>(tools: readonly T[]): readonly T[] {\n  if (tools.length > MCP_MAX_TOOL_LIST_ENTRIES) {\n    throw new McpPayloadTooLargeError(\"MCP tool list\", tools.length, MCP_MAX_TOOL_LIST_ENTRIES);\n  }\n  for (const tool of tools) {\n    const toolBytes = mcpSerializedSizeBytes(tool);\n    if (toolBytes > MCP_MAX_TOOL_DEFINITION_BYTES) {\n      throw new McpPayloadTooLargeError(\n        \"MCP tool definition\",\n        toolBytes,\n        MCP_MAX_TOOL_DEFINITION_BYTES,\n      );\n    }\n  }\n  // Measure the complete JSON array, including brackets and separators. Summing\n  // definitions alone under-counts by one byte per separator plus the array\n  // delimiters and makes the advertised serialized-byte ceiling porous.\n  const totalBytes = mcpSerializedSizeBytes(tools);\n  if (totalBytes > MCP_MAX_TOOL_LIST_BYTES) {\n    throw new McpPayloadTooLargeError(\"MCP tool list\", totalBytes, MCP_MAX_TOOL_LIST_BYTES);\n  }\n  return tools;\n}\n\nexport function assertMcpServerSelectionWithinBounds<T>(servers: readonly T[]): readonly T[] {\n  if (servers.length > MCP_MAX_SELECTED_SERVERS) {\n    throw new McpPayloadTooLargeError(\n      \"selected MCP server count\",\n      servers.length,\n      MCP_MAX_SELECTED_SERVERS,\n    );\n  }\n  return servers;\n}\n\nexport function mcpOuterConnectTimeoutMs(\n  configuredTimeouts: readonly (number | undefined)[],\n): number {\n  return Math.max(\n    MCP_DEFAULT_OUTER_CONNECT_TIMEOUT_MS,\n    ...configuredTimeouts.flatMap((timeoutMs) => (timeoutMs === undefined ? [] : [timeoutMs])),\n  );\n}\n\ntype McpToolListContribution = {\n  entries: number;\n  bytes: number;\n};\n\n/**\n * Atomic aggregate accounting shared by every exposed tools/list in one run.\n * A repeated list for the same source REPLACES its prior contribution, so\n * cache invalidation/relisting cannot ratchet the budget upward. Failed\n * replacements leave the previous accounting intact.\n */\nexport class McpAggregateToolListBudget {\n  private readonly contributions = new Map<string, McpToolListContribution>();\n  private totalEntries = 0;\n  private totalBytes = 0;\n\n  constructor(\n    private readonly label = \"aggregate MCP tool list\",\n    private readonly maxEntries = MCP_MAX_AGGREGATE_TOOL_LIST_ENTRIES,\n    private readonly maxBytes = MCP_MAX_AGGREGATE_TOOL_LIST_BYTES,\n  ) {}\n\n  replace<T>(sourceId: string, tools: readonly T[]): readonly T[] {\n    assertMcpToolListWithinBounds(tools);\n    const contribution = {\n      entries: tools.length,\n      // Conservatively account each server as its complete serialized array.\n      // Summing these arrays slightly over-counts the brackets relative to one\n      // flattened array, which is intentional for a fail-closed hard ceiling.\n      bytes: mcpSerializedSizeBytes(tools),\n    };\n    const previous = this.contributions.get(sourceId) ?? { entries: 0, bytes: 0 };\n    const nextEntries = this.totalEntries - previous.entries + contribution.entries;\n    if (nextEntries > this.maxEntries) {\n      throw new McpPayloadTooLargeError(this.label, nextEntries, this.maxEntries);\n    }\n    const nextBytes = this.totalBytes - previous.bytes + contribution.bytes;\n    if (nextBytes > this.maxBytes) {\n      throw new McpPayloadTooLargeError(this.label, nextBytes, this.maxBytes);\n    }\n    this.contributions.set(sourceId, contribution);\n    this.totalEntries = nextEntries;\n    this.totalBytes = nextBytes;\n    return tools;\n  }\n\n  remove(sourceId: string): void {\n    const previous = this.contributions.get(sourceId);\n    if (!previous) return;\n    this.contributions.delete(sourceId);\n    this.totalEntries -= previous.entries;\n    this.totalBytes -= previous.bytes;\n  }\n\n  snapshot(): Readonly<McpToolListContribution> {\n    return { entries: this.totalEntries, bytes: this.totalBytes };\n  }\n}\n\n/** Stable-order parallel map with a hard in-flight ceiling and fail-stop drain. */\nexport async function boundedParallelMap<T, R>(\n  values: readonly T[],\n  concurrency: number,\n  mapper: (value: T, index: number) => Promise<R>,\n): Promise<R[]> {\n  if (!Number.isInteger(concurrency) || concurrency < 1) {\n    throw new Error(\"bounded parallel map concurrency must be a positive integer\");\n  }\n  if (values.length === 0) return [];\n\n  const results = new Array<R>(values.length);\n  const errors: Array<{ index: number; error: unknown }> = [];\n  let nextIndex = 0;\n  let stopped = false;\n  const worker = async () => {\n    while (!stopped) {\n      const index = nextIndex;\n      if (index >= values.length) return;\n      nextIndex += 1;\n      try {\n        results[index] = await mapper(values[index]!, index);\n      } catch (error) {\n        errors.push({ index, error });\n        stopped = true;\n      }\n    }\n  };\n  await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, () => worker()));\n  if (errors.length > 0) {\n    errors.sort((left, right) => left.index - right.index);\n    throw errors[0]!.error;\n  }\n  return results;\n}\n\n/**\n * Guard normal MCP traffic with the same deployment policy as OAuth traffic.\n * The pinned transport resolves and policy-checks the destination after the\n * caller has composed any credential headers, then performs the final network\n * call through the vetted Agent. It forces manual redirects, so an\n * Authorization-bearing request never follows a provider-controlled Location\n * to an unvalidated host.\n *\n * This module is deliberately agent-loop-free. API code imports the explicit\n * `@opengeni/runtime/mcp-network` leaf rather than the runtime root barrel.\n */\nexport function guardedMcpFetch<TInput extends string | URL | Request>(\n  settings: Pick<Settings, \"environment\" | \"integrationsAllowPrivateNetworkTargets\">,\n  fetchImpl: (input: TInput, init?: RequestInit) => Promise<Response>,\n  options: {\n    maxResponseBytes?: number;\n    dnsLookup?: DnsLookup;\n    requireHttpsOutsideLocalTest?: boolean;\n  } = {},\n): (input: TInput, init?: RequestInit) => Promise<Response> {\n  return async (input: TInput, init?: RequestInit) => {\n    const response = await pinnedFetch(input, init, settings, {\n      fetchImpl: fetchImpl as FetchLike,\n      ...(options.dnsLookup ? { dnsLookup: options.dnsLookup } : {}),\n      label: \"MCP endpoint\",\n      requireHttpsOutsideLocalTest: options.requireHttpsOutsideLocalTest ?? true,\n    });\n    return boundMcpResponseBody(response, options.maxResponseBytes ?? MCP_MAX_RESPONSE_BYTES);\n  };\n}\n\nexport function boundMcpResponseBody(response: Response, maxBytes: number): Response {\n  const declaredLength = Number(response.headers.get(\"content-length\"));\n  if (Number.isFinite(declaredLength) && declaredLength > maxBytes) {\n    void response.body?.cancel().catch(() => undefined);\n    throw new McpPayloadTooLargeError(\"MCP response\", declaredLength, maxBytes);\n  }\n  if (!response.body) {\n    return response;\n  }\n\n  const reader = response.body.getReader();\n  let receivedBytes = 0;\n  const body = new ReadableStream<Uint8Array>({\n    async pull(controller) {\n      try {\n        const chunk = await reader.read();\n        if (chunk.done) {\n          controller.close();\n          return;\n        }\n        receivedBytes += chunk.value.byteLength;\n        if (receivedBytes > maxBytes) {\n          await reader.cancel().catch(() => undefined);\n          controller.error(new McpPayloadTooLargeError(\"MCP response\", receivedBytes, maxBytes));\n          return;\n        }\n        controller.enqueue(chunk.value);\n      } catch (error) {\n        controller.error(error);\n      }\n    },\n    async cancel(reason) {\n      await reader.cancel(reason).catch(() => undefined);\n    },\n  });\n  const bounded = new Response(body, {\n    status: response.status,\n    statusText: response.statusText,\n    headers: response.headers,\n  });\n  Object.defineProperties(bounded, {\n    redirected: { value: response.redirected },\n    type: { value: response.type },\n    url: { value: response.url },\n  });\n  return bounded;\n}\n\nexport async function cancelMcpResponseBody(response: Response): Promise<void> {\n  await response.body?.cancel().catch(() => undefined);\n}\n\n/** Read and rebuild an inbound MCP request before the SDK parses it. */\nexport async function boundedMcpRequest(\n  request: Request,\n  maxBytes = MCP_MAX_INBOUND_REQUEST_BYTES,\n): Promise<Request> {\n  const declared = request.headers.get(\"content-length\");\n  if (declared !== null) {\n    const normalized = declared.trim();\n    if (!/^\\d+$/.test(normalized)) {\n      await request.body?.cancel().catch(() => undefined);\n      throw new McpPayloadTooLargeError(\"MCP request\", 0, maxBytes);\n    }\n    const declaredBytes = Number(normalized);\n    if (!Number.isSafeInteger(declaredBytes) || declaredBytes > maxBytes) {\n      await request.body?.cancel().catch(() => undefined);\n      throw new McpPayloadTooLargeError(\"MCP request\", declaredBytes, maxBytes);\n    }\n  }\n  if (!request.body) {\n    return request;\n  }\n  const reader = request.body.getReader();\n  const chunks: Uint8Array[] = [];\n  let receivedBytes = 0;\n  try {\n    for (;;) {\n      const result = await reader.read();\n      if (result.done) break;\n      receivedBytes += result.value.byteLength;\n      if (receivedBytes > maxBytes) {\n        await reader.cancel().catch(() => undefined);\n        throw new McpPayloadTooLargeError(\"MCP request\", receivedBytes, maxBytes);\n      }\n      chunks.push(result.value);\n    }\n  } catch (error) {\n    await reader.cancel().catch(() => undefined);\n    throw error;\n  } finally {\n    reader.releaseLock();\n  }\n  const body = new Uint8Array(receivedBytes);\n  let offset = 0;\n  for (const chunk of chunks) {\n    body.set(chunk, offset);\n    offset += chunk.byteLength;\n  }\n  return new Request(request, { body, headers: request.headers });\n}\n\nexport async function assertMcpDestinationAllowed(\n  rawUrl: string,\n  settings: Pick<Settings, \"environment\" | \"integrationsAllowPrivateNetworkTargets\">,\n  options: { dnsLookup?: DnsLookup } = {},\n): Promise<void> {\n  await resolvePinnedDestination(rawUrl, settings, {\n    ...(options.dnsLookup ? { dnsLookup: options.dnsLookup } : {}),\n    label: \"MCP endpoint\",\n    requireHttpsOutsideLocalTest: true,\n  });\n}\n\nexport const isNonPublicMcpAddress = isNonPublicAddress;\n"],"mappings":"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","names":[]}