[diegosouzapw]

Summary

The OpenAI→Gemini request helper (convertOpenAIContentToParts) silently dropped HTTP/HTTPS image_url parts and emitted only a console.warn, because Gemini's inlineData requires base64 and the helper is synchronous (can't fetch+encode upstream).

Gemini's Part schema natively supports fileData: { fileUri } for remote URIs — the model fetches the asset itself. This PR uses that path instead of dropping the URL, so vision requests that pass a URL (not a data: URI) reach Gemini intact.

What changes

• open-sse/translator/helpers/geminiHelper.ts: the existing ^https?:// branch now emits parts.push({ fileData: { fileUri, mimeType: "image/*" } }) instead of the strip-query-string console.warn + drop.
• tests/unit/gemini-helper-http-image-url-port344.test.ts (new, 4 cases):
  • https:// URL → fileData { fileUri } part
  • http:// URL → fileData { fileUri } part
  • data: URI → still inlineData (no regression)
  • ftp:// and empty image_url → still dropped (Gemini would reject them)
• CHANGELOG.md: ### 🐛 Fixed entry under [3.8.30].

Why image/* and not a sniffed MIME

Sniffing would require a HEAD request, which would make convertOpenAIContentToParts async — a breaking change for sync callers (the original rationale for the warning text). Gemini infers the concrete MIME from the response when it fetches the asset.

What this is not

• The OmniRoute openai-to-claude translator already passed HTTP/HTTPS URLs through as source: { type: "url", url } (open-sse/translator/request/openai-to-claude.ts:573-578), so the upstream PR's Claude-side change is already covered — no change there.
• Not a refactor of the helper to be async — sync sig preserved, drop-vs-warn behavior simply replaced with the Gemini-native passthrough.

Test plan

• node --import tsx/esm --test tests/unit/gemini-helper-http-image-url-port344.test.ts → 4/4 pass (RED before fix, GREEN after)
• node --import tsx/esm --test tests/unit/gemini-helper.test.ts → 20/20 (existing helper tests, no regression)
• npm run typecheck:core → clean
• npx eslint open-sse/translator/helpers/geminiHelper.ts tests/unit/gemini-helper-http-image-url-port344.test.ts → clean
• npm run check:cycles → no cycles (267 files in scope)
• npm run test:vitest → 193/193 pass

Credit

Adapts the upstream JS implementation by Ibrahim Ryan (@East-rayyy) to OmniRoute's TS helper. Credited via Co-authored-by trailer on the commit.

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.

[gemini-code-assist]

Code Review

This pull request updates the Gemini helper to pass remote HTTP/HTTPS URLs through as fileData parts instead of dropping them, and adds comprehensive unit tests. The reviewer feedback recommends sniffing the MIME type from the URL's file extension rather than hardcoding image/*, which would cause failures for non-image files like PDFs, and suggests updating the tests to assert specific MIME types.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

Hardcoding image/* as the MIME type for all remote URLs can cause issues when the source is actually a document (e.g., a PDF file passed via file_url or docObj?.url). Gemini is strict about MIME types and will fail or reject the request if a PDF is sent with an image/* MIME type.

We can improve this by checking if the source was originally an image (i.e., from imageUrl or imageObj) and sniffing the MIME type from the URL's file extension (e.g., .pdf, .png, .jpg, etc.) before falling back to a sensible default.

          const isImage = fileData === imageUrl?.url || fileData === imageObj?.url;
          let mimeType = isImage ? "image/*" : "application/pdf";
          try {
            const pathname = new URL(fileData).pathname.toLowerCase();
            if (pathname.endsWith(".pdf")) {
              mimeType = "application/pdf";
            } else if (pathname.endsWith(".png")) {
              mimeType = "image/png";
            } else if (pathname.endsWith(".jpg") || pathname.endsWith(".jpeg")) {
              mimeType = "image/jpeg";
            } else if (pathname.endsWith(".webp")) {
              mimeType = "image/webp";
            } else if (pathname.endsWith(".gif")) {
              mimeType = "image/gif";
            } else if (pathname.endsWith(".txt")) {
              mimeType = "text/plain";
            }
          } catch {}
          parts.push({
            fileData: { fileUri: fileData, mimeType },
          });

[gemini-code-assist]

With the extension-based MIME type sniffing implemented, we can assert the exact expected MIME type (image/png) instead of just checking that it is a non-empty string.

  assert.equal(fileData.mimeType, "image/png");

[gemini-code-assist]

Assert the exact expected MIME type (image/jpeg) for the .jpg image URL.

  assert.equal(fileData.fileUri, "http://example.com/dog.jpg");
  assert.equal(fileData.mimeType, "image/jpeg");

[gemini-code-assist]

Let's add a test case to verify that non-image remote URLs (such as PDFs) are correctly identified and assigned the appropriate MIME type (application/pdf).

  const fileDataParts = parts.filter((p: Record<string, unknown>) => p.fileData);
  assert.equal(fileDataParts.length, 0);
});

test("convertOpenAIContentToParts: passes remote PDF document URL through with application/pdf MIME type", () => {
  const content = [
    { type: "document", document: { url: "https://example.com/report.pdf" } },
  ];

  const parts = gemini.convertOpenAIContentToParts(content);

  assert.equal(parts.length, 1);
  const fileDataPart = parts[0] as Record<string, unknown>;
  assert.ok(fileDataPart.fileData, "expected fileData on the emitted part");
  const fileData = fileDataPart.fileData as Record<string, unknown>;
  assert.equal(fileData.fileUri, "https://example.com/report.pdf");
  assert.equal(fileData.mimeType, "application/pdf");
});