"Lost Connection" error after calling bound service worker

Hi All,
I have 2 workers, 1 that validates a request by doing a JWT token validation, and another that is basically a proxy to Google Maps.

When the proxy is called, it calls a bound service (auth) to validate the request via the JWT token. This auth service makes a fetch to an endpoint to get public keys it needs to validate the token, then validates (or rejects) and return the response.

The proxy will either return the bad response from the call to the auth worker if rejected or continue to pass the request along to Google Maps. It is at this point that I get the “connection list” error.

If I call the auth service by itself, it works. If I call the proxy worker direction and disable the auth check, it works. When the auth check is enabled I get a connection lost error when it makes a fetch to the Google API.

Tailing the logs I see the auth request, which passes, then the attempt to call the maps API, which causes the connection lost error.

Is there something I need to be doing to prevent this? Here is my code:

Auth worker:

export default {
	async fetch(request: Request, env: Env): Promise<Response> {
		const token = request.headers.get('X-Token');
		if (!token) {
                    console.log('No token was found');
                    return new Response("Unauthorized", { status: 401 });
                }
                // This function makes a fetch call to a JWKS endpoint...
		const valid = await verifyToken(token, env);
		if (!valid) {
                        console.log('No app Id was found');
			return new Response("Unauthorized", { status: 401 });
		}
		return new Response(`{"valid":true}`, {
			headers: { "content-type": "text/json" }
		});
	},
};

Proxy worker:

export default {
	async fetch(request: Request, env: Env): Promise<Response> {
		return env
			.auth
			.fetch(request.clone())
			.then(res => {
				if (res.status !== 200) 
					return res
				else 
					return proxyRequest(request, env);
			})
			.catch(err => {
				console.log('ERROR', err.message);
				return new Response('Internal error', { status: 500 });
			});
	}
};

const proxyRequest = async (request: Request, env: Env): Promise<Response> => {
	try {
		const url = new URL(request.url);

		const apiUrl = new URL(env.GOOGLE_MAPS_HOST);
		apiUrl.pathname += url.pathname;
		apiUrl.search = new URLSearchParams(url.search).toString();

                // ERROR HAPPENS HERE
		console.log('Calling google maps api at', apiUrl.toString());
		const response = await fetch(apiUrl.toString(), {
			method: request.method,
			body: request.body,
			headers: {
				'X-Goog-Api-Key': env.API_KEY,
			}
		});

		console.log(']Got response status', response.ok, response.status, response.statusText);

		if (!response?.ok) {
			console.log('Invalid response:', response.status, response.statusText);
			return new Response(response.statusText, { status: response.status });
		}

		const data = await response.json();

		return new Response(JSON.stringify(data), {
			headers: { "content-type": "text/json" }
		});
	} catch (err: any) {
		console.log('Error', err);
		return new Response(err.message, { status: 500 });
	}

}