Please address the comments from this code review:

## Overall Comments
- The `isPublicExternalUrl` helper currently only checks the protocol; consider explicitly rejecting localhost, private-network, or non-DNS hosts so the name better matches its behavior and avoids relying solely on `ssrfSafeFetch`.
- Using `HEAD` in `validateExternalUrl` may fail on servers that don’t implement it correctly; you might want to fall back to a `GET` with `method: 'GET', signal` and `redirect: 'manual'` or similar if the initial `HEAD` request returns 405/501.
- The Google-specific constraints (`GOOGLE_EXTERNAL_URL_SUPPORTED_TYPES`, `MAX_*` limits) are now embedded in `uriParser.ts`; consider moving them to a separate Gemini/Google-specific config module to keep URI parsing utilities more generic.

## Individual Comments

### Comment 1
<location> `packages/model-runtime/src/utils/uriParser.ts:121-130` </location>
<code_context>
+      };
+    }
+
+    const contentLength = Number.parseInt(res.headers.get('content-length') || '0', 10);
+    const contentType = (res.headers.get('content-type') || '').split(';')[0].trim().toLowerCase();
+
+    // Check MIME type support
+    if (!GOOGLE_EXTERNAL_URL_SUPPORTED_TYPES.has(contentType)) {
+      return {
+        contentLength,
+        contentType,
+        isValid: false,
+        reason: `Unsupported content type: ${contentType}`,
+      };
+    }
+
+    // Check file size - External URLs support 100MB for all file types
+    // (Unlike inline data where PDFs are limited to 50MB)
+    if (contentLength > MAX_EXTERNAL_URL_SIZE) {
+      return {
+        contentLength,
</code_context>

<issue_to_address>
**issue (bug_risk):** Treat missing or non-numeric Content-Length more explicitly to avoid silently bypassing size checks.

Because `content-length` defaults to `0` when missing or non-numeric, the size limit check is effectively bypassed and very large files may be accepted. Consider either rejecting URLs with missing/invalid `content-length`, or returning a distinct `reason` indicating the size couldn’t be determined instead of treating it as `0`.
</issue_to_address>

### Comment 2
<location> `packages/model-runtime/src/core/contextBuilders/google.ts:60-74` </location>
<code_context>
+
+        // Try to use External URL feature for public URLs to avoid re-uploading
+        // This allows Google to fetch the file directly, reducing transfer costs
+        if (isPublicExternalUrl(url)) {
+          const validation = await validateExternalUrl(url);
+          if (validation.isValid) {
+            return {
+              fileData: {
</code_context>

<issue_to_address>
**suggestion (performance):** Calling `validateExternalUrl` for videos currently always fails due to the supported MIME set, adding extra latency.

For `video_url`, `validateExternalUrl` checks `GOOGLE_EXTERNAL_URL_SUPPORTED_TYPES`, which only includes text/image/pdf, so all video URLs will always fail validation and fall back to base64 after an extra HEAD request. To avoid this unnecessary round-trip, consider either gating the validation behind a flag/config for videos, skipping validation for videos until Google supports them, or updating the supported types to include `video/*` once that support is available.

```suggestion
        // Try to use External URL feature for public URLs to avoid re-uploading.
        // This allows Google to fetch the file directly, reducing transfer costs.
        // NOTE: We only validate external URLs for images; videos are not yet supported
        // by GOOGLE_EXTERNAL_URL_SUPPORTED_TYPES and would always fail validation,
        // causing an unnecessary HEAD request before falling back to base64.
        if (content.type === 'image_url' && isPublicExternalUrl(url)) {
          const validation = await validateExternalUrl(url);
          if (validation.isValid) {
            return {
              fileData: {
                fileUri: url,
                mimeType: validation.contentType,
              },
              thoughtSignature: GEMINI_MAGIC_THOUGHT_SIGNATURE,
            };
          }
          // If validation fails, fall back to base64 conversion
        }
```
</issue_to_address>