Merge pull request #730 from RhysSullivan/codex/remove-openapi-import-limits

[codex] Remove OpenAPI import size limits

Author: RhysSullivan

apps/cloud/src/mcp.ts

@@ -72,7 +72,6 @@ const MCP_PATH = "/mcp";
 const PROTECTED_RESOURCE_METADATA_PATH = "/.well-known/oauth-protected-resource/mcp";
 const PROTECTED_RESOURCE_METADATA_URL = `${RESOURCE_ORIGIN}${PROTECTED_RESOURCE_METADATA_PATH}`;
 const RESOURCE_URL = `${RESOURCE_ORIGIN}${MCP_PATH}`;
-export const MAX_MCP_JSON_RPC_BODY_BYTES = 1_000_000;
 
 type McpUnauthorizedReason = "missing_bearer" | "invalid_token";
 
@@ -108,18 +107,6 @@ const corsPreflight = HttpServerResponse.empty({
   headers: CORS_PREFLIGHT_HEADERS,
 });
 
-const contentLength = (request: Request): number | null => {
-  const value = request.headers.get("content-length");
-  if (!value) return null;
-  const parsed = Number(value);
-  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
-};
-
-const isBodyTooLarge = (request: Request, maxBytes: number): boolean => {
-  const length = contentLength(request);
-  return length !== null && length > maxBytes;
-};
-
 // ---------------------------------------------------------------------------
 // Auth
 // ---------------------------------------------------------------------------
@@ -315,11 +302,7 @@ const readJsonRpcEnvelope = (request: Request): Effect.Effect<Option.Option<Json
     try: () => request.clone().text(),
     catch: () => undefined,
   }).pipe(
-    Effect.map((text) =>
-      text && text.length <= MAX_MCP_JSON_RPC_BODY_BYTES
-        ? decodeJsonRpcEnvelopeString(text)
-        : Option.none(),
-    ),
+    Effect.map((text) => (text ? decodeJsonRpcEnvelopeString(text) : Option.none())),
     Effect.catchCause(() => Effect.succeed(Option.none())),
     Effect.withSpan("mcp.request.read_json_rpc"),
   );
@@ -691,23 +674,18 @@ export const mcpApp: Effect.Effect<
     return yield* authTemporarilyUnavailable(authResult.failure);
   }
   const authValue = authResult.success;
-  const bodyTooLarge =
-    request.method === "POST" && isBodyTooLarge(request, MAX_MCP_JSON_RPC_BODY_BYTES);
 
   // Annotate before dispatch so even 401s show up with what we know. Only
   // POST bodies are JSON-RPC payloads worth parsing; GET (SSE) and DELETE
   // don't carry one.
   yield* annotateMcpRequest(request, {
     token: isMcpAuthorized(authValue) ? authValue.token : null,
-    parseBody: request.method === "POST" && isMcpAuthorized(authValue) && !bodyTooLarge,
+    parseBody: request.method === "POST" && isMcpAuthorized(authValue),
   });
 
   if (isMcpUnauthorized(authValue)) {
     return unauthorized(authValue, PROTECTED_RESOURCE_METADATA_URL);
   }
-  if (bodyTooLarge) {
-    return jsonRpcError(413, -32000, "Request body too large");
-  }
   const token = authValue.token;
   switch (request.method) {
     case "POST":

apps/cloud/src/sentry-tunnel.ts

@@ -1,7 +1,5 @@
 import { Data, Effect, Schema } from "effect";
 
-export const MAX_SENTRY_ENVELOPE_BODY_BYTES = 200_000;
-
 class SentryTunnelError extends Data.TaggedError("SentryTunnelError")<{
   readonly cause?: unknown;
 }> {}
@@ -16,39 +14,12 @@ const decodeSentryEnvelopeHeader = Schema.decodeUnknownEffect(
 
 const badSentryEnvelopeResponse = () => new Response("bad envelope", { status: 400 });
 
-const requestContentLength = (request: Request): number | null => {
-  const value = request.headers.get("content-length");
-  if (!value) return null;
-  const parsed = Number(value);
-  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
-};
-
-const readLimitedRequestText = (request: Request, maxBytes: number) =>
+export const handleSentryTunnelRequest = (request: Request, configuredDsn: string) =>
   Effect.gen(function* () {
-    const length = requestContentLength(request);
-    if (length !== null && length > maxBytes) {
-      return yield* new SentryTunnelError({ cause: "payload_too_large" });
-    }
-    const text = yield* Effect.tryPromise({
+    const envelope = yield* Effect.tryPromise({
       try: () => request.text(),
       catch: (cause) => new SentryTunnelError({ cause }),
     });
-    if (text.length > maxBytes) {
-      return yield* new SentryTunnelError({ cause: "payload_too_large" });
-    }
-    return text;
-  });
-
-export const handleSentryTunnelRequest = (request: Request, configuredDsn: string) =>
-  Effect.gen(function* () {
-    const envelope = yield* readLimitedRequestText(request, MAX_SENTRY_ENVELOPE_BODY_BYTES).pipe(
-      Effect.catchTag("SentryTunnelError", (error) =>
-        error.cause === "payload_too_large"
-          ? Effect.succeed(new Response("payload too large", { status: 413 }))
-          : Effect.fail(error),
-      ),
-    );
-    if (envelope instanceof Response) return envelope;
     const firstLine = envelope.slice(0, envelope.indexOf("\n"));
     const header = yield* decodeSentryEnvelopeHeader(firstLine).pipe(
       Effect.mapError((cause) => new SentryTunnelError({ cause })),

apps/cloud/src/start.test.ts

@@ -3287,7 +3287,7 @@ export const createExecutor = <const TPlugins extends readonly AnyPlugin[] = []>
     const sourceDetectionMaxUrlLength = config.sourceDetection?.maxUrlLength ?? 2_048;
     const sourceDetectionMaxDetectors = config.sourceDetection?.maxDetectors ?? 6;
     const sourceDetectionMaxResults = config.sourceDetection?.maxResults ?? 4;
-    const sourceDetectionTimeout = config.sourceDetection?.timeout ?? "5 seconds";
+    const sourceDetectionTimeout = config.sourceDetection?.timeout ?? "60 seconds";
     const sourceDetectionHostedOutboundPolicy =
       config.sourceDetection?.hostedOutboundPolicy ?? config.httpClientLayer !== undefined;
 

packages/core/sdk/src/executor.ts

@@ -99,44 +99,4 @@ describe("hosted outbound HTTP client", () => {
       expect(calls).toBe(1);
     }),
   );
-
-  it.effect("rejects responses with content-length beyond the configured limit", () =>
-    Effect.gen(function* () {
-      const fakeFetch: typeof globalThis.fetch = (async () =>
-        new Response("too large", {
-          status: 200,
-          headers: { "content-length": "9" },
-        })) as typeof globalThis.fetch;
-
-      const result = yield* Effect.gen(function* () {
-        const client = yield* HttpClient.HttpClient;
-        return yield* client.execute(HttpClientRequest.get("https://public.example/spec"));
-      }).pipe(
-        Effect.provide(makeHostedHttpClientLayer({ fetch: fakeFetch, maxResponseBytes: 8 })),
-        Effect.result,
-      );
-
-      expect(Result.isFailure(result)).toBe(true);
-    }),
-  );
-
-  it.effect("rejects streamed responses that exceed the configured limit", () =>
-    Effect.gen(function* () {
-      const fakeFetch: typeof globalThis.fetch = (async () =>
-        new Response("too large", { status: 200 })) as typeof globalThis.fetch;
-
-      const result = yield* Effect.gen(function* () {
-        const client = yield* HttpClient.HttpClient;
-        const response = yield* client.execute(
-          HttpClientRequest.get("https://public.example/spec"),
-        );
-        return yield* response.text;
-      }).pipe(
-        Effect.provide(makeHostedHttpClientLayer({ fetch: fakeFetch, maxResponseBytes: 8 })),
-        Effect.result,
-      );
-
-      expect(Result.isFailure(result)).toBe(true);
-    }),
-  );
 });

packages/core/sdk/src/hosted-http-client.test.ts

@@ -12,12 +12,9 @@ export class HostedOutboundRequestBlocked extends Schema.TaggedErrorClass<Hosted
 export interface HostedHttpClientOptions {
   readonly allowLocalNetwork?: boolean;
   readonly maxRedirects?: number;
-  readonly maxResponseBytes?: number;
   readonly fetch?: typeof globalThis.fetch;
 }
 
-const DEFAULT_MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
-
 const parseIpv4 = (hostname: string): readonly [number, number, number, number] | null => {
   const parts = hostname.split(".");
   if (parts.length !== 4) return null;
@@ -158,69 +155,11 @@ const guardFetch = (
         current = next.toString();
         continue;
       }
-      return guardResponseBody(
-        response,
-        url,
-        options.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES,
-      );
+      return response;
     }
-    const url = current instanceof Request ? current.url : String(current);
-    const response = await underlying(current, { ...init, redirect: "manual" });
-    return guardResponseBody(response, url, options.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES);
+    return await underlying(current, { ...init, redirect: "manual" });
   }) as typeof globalThis.fetch;
 
-const guardResponseBody = (response: Response, url: string, maxResponseBytes: number): Response => {
-  if (!Number.isFinite(maxResponseBytes) || maxResponseBytes <= 0 || !response.body) {
-    return response;
-  }
-
-  const contentLength = response.headers.get("content-length");
-  if (contentLength !== null) {
-    const parsed = Number(contentLength);
-    if (Number.isFinite(parsed) && parsed > maxResponseBytes) {
-      // oxlint-disable-next-line executor/no-try-catch-or-throw -- boundary: fetch-compatible response adapter must reject oversized responses
-      throw new HostedOutboundRequestBlocked({
-        url,
-        reason: "Response body is too large",
-      });
-    }
-  }
-
-  let total = 0;
-  const reader = response.body.getReader();
-  const limitedBody = new ReadableStream<Uint8Array>({
-    async pull(controller) {
-      const next = await reader.read();
-      if (next.done) {
-        controller.close();
-        return;
-      }
-
-      total += next.value.byteLength;
-      if (total > maxResponseBytes) {
-        controller.error(
-          new HostedOutboundRequestBlocked({
-            url,
-            reason: "Response body is too large",
-          }),
-        );
-        return;
-      }
-
-      controller.enqueue(next.value);
-    },
-    cancel(reason) {
-      return reader.cancel(reason);
-    },
-  });
-
-  return new Response(limitedBody, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers,
-  });
-};
-
 export const makeHostedHttpClientLayer = (
   options: HostedHttpClientOptions = {},
 ): Layer.Layer<HttpClient.HttpClient> =>

packages/core/sdk/src/hosted-http-client.ts

@@ -20,7 +20,7 @@ class OpenApiExtractionErrorFromParse extends OpenApiExtractionError {}
  * HttpClient so the caller chooses the transport via layer — in Cloudflare
  * Workers, `FetchHttpClient.layer` binds to the Workers-native `fetch` and
  * avoids json-schema-ref-parser's Node-polyfill http resolver, which hangs
- * in production. Bounded by a 20s timeout.
+ * in production. Bounded by a 60s timeout.
  */
 export const fetchSpecText = Effect.fn("OpenApi.fetchSpecText")(function* (
   url: string,
@@ -38,7 +38,7 @@ export const fetchSpecText = Effect.fn("OpenApi.fetchSpecText")(function* (
     request = HttpClientRequest.setHeader(request, name, value);
   }
   const response = yield* client.execute(request).pipe(
-    Effect.timeout(Duration.seconds(20)),
+    Effect.timeout(Duration.seconds(60)),
     Effect.mapError(
       (_cause) =>
         new OpenApiParseError({