fix: handling text, vtt, srt response format for transcriptions

[sammaji]

Summary

Adds support for plain-text transcription response formats (text, srt, vtt) in OpenAI transcription requests. Previously, the system only handled JSON responses, but OpenAI's transcription API can return raw text depending on the response_format parameter.

Changes

• Added isPlainTextTranscriptionFormat() utility function to detect when transcription requests use plain-text formats
• Modified transcription response handling to parse plain-text responses directly as strings instead of attempting JSON unmarshaling
• Updated HTTP router to detect plain-text transcription responses and return them with the original Content-Type header from the provider
• Added isPlainTextTranscriptionResponse() helper to identify plain-text responses by Content-Type
• Removed extraneous blank lines throughout the OpenAI provider code for consistency

Type of change

• Feature
• Bug fix

Affected areas

• Core (Go)
• Transports (HTTP)
• Providers/Integrations

How to test

Test transcription requests with different response formats:

# Test JSON format (existing behavior)
curl -X POST /v1/audio/transcriptions \
  -H "Content-Type: multipart/form-data" \
  -F "file=@audio.mp3" \
  -F "model=whisper-1" \
  -F "response_format=json"

# Test plain-text formats (new behavior)
curl -X POST /v1/audio/transcriptions \
  -H "Content-Type: multipart/form-data" \
  -F "file=@audio.mp3" \
  -F "model=whisper-1" \
  -F "response_format=text"

curl -X POST /v1/audio/transcriptions \
  -H "Content-Type: multipart/form-data" \
  -F "file=@audio.mp3" \
  -F "model=whisper-1" \
  -F "response_format=srt"

# Run tests
go test ./core/providers/openai/...
go test ./transports/bifrost-http/...

Screenshots/Recordings

N/A

Breaking changes

• No

This change maintains backward compatibility while adding support for additional response formats.

Related issues

N/A

Security considerations

No security implications - this change only affects response format handling and preserves existing authentication and validation flows.

Checklist

• I read docs/contributing/README.md and followed the guidelines
• I added/updated tests where appropriate
• I updated documentation where needed
• I verified builds succeed (Go and UI)
• I verified the CI pipeline passes locally if applicable

[sammaji]

• fix: handling text, vtt, srt response format for transcriptions #2102 👈 (View in Graphite)
• v1.5.0

This stack of pull requests is managed by Graphite. Learn more about stacking.

[coderabbitai]

📝 Walkthrough

Summary by CodeRabbit

• New Features

  • Transcription supports plain-text formats (text, SRT, VTT) and can return raw plain-text payloads.

• Improvements

  • HTTP endpoints may return raw provider bytes along with provider headers for plain-text transcriptions.
  • Transcription responses now retain and backfill response-format metadata for better downstream handling.
  • Minor formatting and comment cleanups.

Walkthrough

Transcription responses now carry a provider-selected ResponseFormat and, for plain-text formats (text/srt/vtt), are propagated and returned as raw bytes through the router and converters instead of being JSON-marshaled; accompanying schema backfill and provider/converter/router updates implement this short‑circuit. Minor formatting edits applied.

Changes

Cohort / File(s)	Summary
OpenAI provider core/providers/openai/openai.go	Whitespace/line-wrap cleanup; transcription handlers now assign plain-text transcription bodies directly (bypass JSON unmarshal) when format is plain-text.
Transcription schema core/schemas/transcriptions.go	Added ResponseFormat *string (json:"-"); added BackfillParams(req *BifrostTranscriptionRequest) to populate response format from request; added IsPlainTextTranscriptionFormat(format *string) bool.
HTTP integration — router transports/bifrost-http/integrations/router.go	handleNonStreamingRequest treats a []byte from TranscriptionResponseConverter as a raw response: applies provider headers, writes HTTP 200, and returns raw bytes immediately. Minor formatting cleanup.
HTTP integration — OpenAI converter transports/bifrost-http/integrations/openai.go	TranscriptionResponseConverter short-circuits to []byte(resp.Text) when resp.ResponseFormat is plain-text; minor spacing edits.
Core request flow core/bifrost.go	After non-streaming transcription provider return, calls transcriptionResponse.BackfillParams(...) to copy request format into response before downstream conversion.
Formatting-only edits core/providers/openai/openai.go (and minor spacing elsewhere)	Line-wrapping and whitespace adjustments with no behavior change beyond the items above.

Sequence Diagram(s)

sequenceDiagram
  participant Client
  participant Router
  participant Provider
  participant Schema
  participant Converter

  Client->>Router: POST transcription request (includes params.response_format)
  Router->>Provider: call provider.Transcription(...)
  Provider-->>Router: returns BifrostTranscriptionResponse (may include provider raw body)
  Router->>Schema: BackfillParams(req) — copy ResponseFormat into response
  Router->>Converter: TranscriptionResponseConverter(response)
  alt ResponseFormat is plain-text
    Converter-->>Router: raw []byte(resp.Text)
    Router->>Client: set headers, HTTP 200, write raw bytes
  else Non-plain format (JSON)
    Converter-->>Router: structured response
    Router->>Client: write JSON-encoded response
  end

Loading

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~25 minutes

Poem

I hop through streams of bytes and rhyme,
preserving format, one leap at a time.
When text is plain, I skip the mold—
raw words delivered, neat and bold.
🐇📜

🚥 Pre-merge checks | ✅ 3

✅ Passed checks (3 passed)

Check name	Status	Explanation
Title check	✅ Passed	The title clearly and specifically describes the main change: adding support for text, vtt, and srt response formats in transcription handling.
Description check	✅ Passed	The description comprehensively covers the summary, changes, type, affected areas, testing steps, and other template sections. All required information is present and well-documented.
Docstring Coverage	✅ Passed	Docstring coverage is 80.00% which is sufficient. The required threshold is 80.00%.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing Touches

📝 Generate docstrings

• Create stacked PR
• Commit on current branch

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch 03-16-fix_handling_text_vtt_srt_response_format_for_transcriptions

---

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[coderabbitai]

Actionable comments posted: 2

🧹 Nitpick comments (1)

core/providers/openai/openai.go (1)

2521-2521: Follow up on the TODO in transcription response parsing.

At Line 2521, the TODO leaves this path using bespoke raw-response parsing rather than the shared handler. I can draft a focused cleanup PR if you want.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@core/providers/openai/openai.go` at line 2521, Replace the bespoke
transcription response parsing at the TODO with the shared handler: call
HandleProviderResponse (the existing shared response handler) instead of custom
raw parsing in the transcription response path, adapt the transcription-specific
code to transform the provider output into the shape HandleProviderResponse
expects (or add a small adapter function e.g.,
adaptTranscriptionToProviderResponse), and remove the inline parsing logic so
all provider responses go through HandleProviderResponse for consistent error
handling, logging, and struct normalization (update any local variables or
return types in the surrounding transcription handling function to use the
handler's output).

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@core/providers/openai/openai.go`:
- Around line 2455-2462: The code in isPlainTextTranscriptionFormat branch sets
providerResponseHeaders["Content-Type"], introducing mixed-case keys; change it
to use a lowercased header key ("content-type") when assigning the value from
resp.Header.ContentType(), ensuring providerResponseHeaders is created if nil
and that all provider response header keys are normalized to lowercase for
downstream filtering/lookup (reference symbols: isPlainTextTranscriptionFormat,
providerResponseHeaders, resp.Header.ContentType()).

In `@transports/bifrost-http/integrations/router.go`:
- Around line 1068-1074: The code reads ProviderResponseHeaders["Content-Type"]
with exact casing which can miss variants like "content-type"; change to a
case-insensitive lookup: scan
transcriptionResponse.ExtraFields.ProviderResponseHeaders for a key that equals
"Content-Type" case-insensitively (e.g. using strings.EqualFold or
http.CanonicalHeaderKey on keys) and assign its value to ct, then call
isPlainTextTranscriptionResponse(ct) and proceed with the existing plain-text
bypass; reference ProviderResponseHeaders, isPlainTextTranscriptionResponse, and
ExtractProviderResponseHeaders to locate and update the lookup logic.

---

Nitpick comments:
In `@core/providers/openai/openai.go`:
- Line 2521: Replace the bespoke transcription response parsing at the TODO with
the shared handler: call HandleProviderResponse (the existing shared response
handler) instead of custom raw parsing in the transcription response path, adapt
the transcription-specific code to transform the provider output into the shape
HandleProviderResponse expects (or add a small adapter function e.g.,
adaptTranscriptionToProviderResponse), and remove the inline parsing logic so
all provider responses go through HandleProviderResponse for consistent error
handling, logging, and struct normalization (update any local variables or
return types in the surrounding transcription handling function to use the
handler's output).

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: d66050b0-19db-45af-9e75-1bcafd7cf476

📥 Commits

Reviewing files that changed from the base of the PR and between 2f8d1a1 and 7b404aa.

📒 Files selected for processing (4)

• core/providers/openai/openai.go
• core/providers/openai/utils.go
• transports/bifrost-http/integrations/router.go
• transports/bifrost-http/integrations/utils.go

[coderabbitai]

♻️ Duplicate comments (1)

core/providers/openai/openai.go (1)

2458-2465: ⚠️ Potential issue | 🟠 Major

Normalize provider response header key to lowercase.

This still writes mixed-case "Content-Type" into providerResponseHeaders, which can break downstream lookups expecting normalized keys.

🔧 Proposed fix

-		providerResponseHeaders["Content-Type"] = string(resp.Header.ContentType())
+		if contentType := strings.TrimSpace(string(resp.Header.ContentType())); contentType != "" {
+			providerResponseHeaders["content-type"] = contentType
+		}

Based on learnings: provider response headers should be normalized to lowercase before forwarding/filtering.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@core/providers/openai/openai.go` around lines 2458 - 2465, The code currently
sets providerResponseHeaders["Content-Type"] which can break downstream lookups
expecting lowercase keys; update the logic in the block that checks
request.Params and
schemas.IsPlainTextTranscriptionFormat(request.Params.ResponseFormat) so it
writes the header under the normalized lowercase key "content-type" (still
ensuring providerResponseHeaders is initialized) and use
resp.Header.ContentType() for the value; modify the assignment to
providerResponseHeaders to use the lowercase key instead of "Content-Type".

🧹 Nitpick comments (1)

core/providers/openai/openai.go (1)

2524-2524: Resolve the TODO in the JSON transcription path.

Line 2524 leaves an open gap in consistency (HandleProviderResponse integration). Please either implement it in this PR or track it explicitly before merge.

I can draft the refactor diff for this path if you want.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@core/providers/openai/openai.go` at line 2524, The JSON transcription path
left a TODO where HandleProviderResponse should be invoked; replace the TODO
with a call to HandleProviderResponse (the existing function used elsewhere for
normalizing provider outputs) passing the provider response object, the current
context/metadata (e.g., transcription request/response structs), and the logger,
then handle its returned structured result and error—propagate errors upstream
or convert them to the same error handling used in sibling paths, and ensure any
required types or fields (e.g., providerResponse, ctx, transcriptionID/metadata)
are prepared before the call; if the current function signature lacks values
needed by HandleProviderResponse, extend it minimally to accept them so behavior
is consistent with other provider paths that already use HandleProviderResponse.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Duplicate comments:
In `@core/providers/openai/openai.go`:
- Around line 2458-2465: The code currently sets
providerResponseHeaders["Content-Type"] which can break downstream lookups
expecting lowercase keys; update the logic in the block that checks
request.Params and
schemas.IsPlainTextTranscriptionFormat(request.Params.ResponseFormat) so it
writes the header under the normalized lowercase key "content-type" (still
ensuring providerResponseHeaders is initialized) and use
resp.Header.ContentType() for the value; modify the assignment to
providerResponseHeaders to use the lowercase key instead of "Content-Type".

---

Nitpick comments:
In `@core/providers/openai/openai.go`:
- Line 2524: The JSON transcription path left a TODO where
HandleProviderResponse should be invoked; replace the TODO with a call to
HandleProviderResponse (the existing function used elsewhere for normalizing
provider outputs) passing the provider response object, the current
context/metadata (e.g., transcription request/response structs), and the logger,
then handle its returned structured result and error—propagate errors upstream
or convert them to the same error handling used in sibling paths, and ensure any
required types or fields (e.g., providerResponse, ctx, transcriptionID/metadata)
are prepared before the call; if the current function signature lacks values
needed by HandleProviderResponse, extend it minimally to accept them so behavior
is consistent with other provider paths that already use HandleProviderResponse.

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: 7eebff3a-7a25-48d1-815d-f9831a0590e2

📥 Commits

Reviewing files that changed from the base of the PR and between 7b404aa and 2970a18.

📒 Files selected for processing (4)

• core/providers/openai/openai.go
• core/schemas/transcriptions.go
• transports/bifrost-http/integrations/openai.go
• transports/bifrost-http/integrations/router.go

🚧 Files skipped from review as they are similar to previous changes (1)

• transports/bifrost-http/integrations/router.go

[sammaji]

@coderabbitai full review

I changed my approach. The TranscriptionResponseConverter for openai integraion now looks at the ResponseType field in BifrostTranscriptionResponse (set by the providers). If it is of a non-json type, we are returning raw bytes. This is forwarded by the router along with the headers.

[coderabbitai]

@sammaji Thanks for the explanation! The approach makes sense — having TranscriptionResponseConverter check ResponseFormat and return raw bytes for plain-text formats (text, srt, vtt), with the router forwarding them alongside provider headers, is a clean design. I'll do a full review of the changes now.

✅ Actions performed

Full review triggered.

[coderabbitai]

Actionable comments posted: 1

🧹 Nitpick comments (1)

core/providers/openai/openai.go (1)

2516-2516: Please resolve or track the TODO in this parsing path before merge.

Line 2516 leaves known divergence in response handling behavior for this endpoint. If you want, I can draft the HandleProviderResponse integration patch and a focused test case.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@core/providers/openai/openai.go` at line 2516, The parsing path currently
leaves a TODO where HandleProviderResponse should be invoked; replace the TODO
with a call to HandleProviderResponse passing the raw provider response object,
the parsed result structure, and context/metadata (e.g., request ID, provider
name) so the unified response handling, error mapping, and metrics/telemetry
behavior is preserved; ensure you handle returned error from
HandleProviderResponse (propagate or convert to the existing error flow used in
this function) and add/update any unit tests around the endpoint to cover both
successful and error cases for HandleProviderResponse integration.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@core/providers/openai/openai.go`:
- Around line 2397-2399: The plain-text detection is currently gated only on
request.Params.ResponseFormat which misses cases where format arrives via
another path; update the handling around schemas.IsPlainTextTranscriptionFormat
so it first computes a single boolean (e.g., isPlainText) by checking
request.Params.ResponseFormat if present and falling back to the lpResult
response content-type header (or other request-level format) and then reuse that
boolean in both branches where lpResult.ResponseBody is processed (the blocks
referencing schemas.IsPlainTextTranscriptionFormat, response.Text,
sonic.Unmarshal, and lpResult.ResponseBody) so plain-text bodies set
response.Text and non-plain JSON bodies go through sonic.Unmarshal consistently.

---

Nitpick comments:
In `@core/providers/openai/openai.go`:
- Line 2516: The parsing path currently leaves a TODO where
HandleProviderResponse should be invoked; replace the TODO with a call to
HandleProviderResponse passing the raw provider response object, the parsed
result structure, and context/metadata (e.g., request ID, provider name) so the
unified response handling, error mapping, and metrics/telemetry behavior is
preserved; ensure you handle returned error from HandleProviderResponse
(propagate or convert to the existing error flow used in this function) and
add/update any unit tests around the endpoint to cover both successful and error
cases for HandleProviderResponse integration.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: 3018ac61-8515-4406-bbf7-e00a7c7b49f0

📥 Commits

Reviewing files that changed from the base of the PR and between 2970a18 and 2d3c5f8.

📒 Files selected for processing (4)

• core/providers/openai/openai.go
• core/schemas/transcriptions.go
• transports/bifrost-http/integrations/openai.go
• transports/bifrost-http/integrations/router.go

[coderabbitai]

@sammaji Thanks for the explanation! The updated approach — having TranscriptionResponseConverter inspect the ResponseFormat field on BifrostTranscriptionResponse and return raw bytes for plain-text formats (text, srt, vtt), with the router forwarding those bytes along with provider headers — is clean and well-structured. Triggering a full review now.

✅ Actions performed

Full review triggered.

[coderabbitai]

♻️ Duplicate comments (1)

core/providers/openai/openai.go (1)

2397-2399: ⚠️ Potential issue | 🟠 Major

Plain-text detection is still coupled to request.Params.ResponseFormat.

Line 2397 and Line 2494 only enable plain-text handling when request.Params is populated. If format is provided via another request path, Line 2502 can still attempt JSON unmarshal on plain text.

🔧 Proposed fix (single boolean + content-type fallback)

+isPlainTextResponse := request.Params != nil && schemas.IsPlainTextTranscriptionFormat(request.Params.ResponseFormat)
+if !isPlainTextResponse {
+	if ct, ok := providerResponseHeaders["content-type"]; ok {
+		ct = strings.ToLower(strings.TrimSpace(strings.Split(ct, ";")[0]))
+		isPlainTextResponse = ct == "text/plain" || ct == "text/vtt" || ct == "application/x-subrip"
+	}
+}
-if request.Params != nil && schemas.IsPlainTextTranscriptionFormat(request.Params.ResponseFormat) {
+if isPlainTextResponse {
 	response.Text = string(copiedResponseBody)
 	if sendBackRawResponse {
 		rawResponse = string(copiedResponseBody)
 	}
 } else if customResponseHandler != nil {

Also applies to: 2494-2503

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@core/providers/openai/openai.go` around lines 2397 - 2399, Compute a single
boolean like isPlainText before deciding how to decode lpResult: set isPlainText
= (request.Params != nil &&
schemas.IsPlainTextTranscriptionFormat(request.Params.ResponseFormat)) ||
fallback check (e.g., inspect lpResult.ContentType header for "text/plain" or
otherwise detect plain-text by attempting a safe sniff of
lpResult.ResponseBody). Then use that isPlainText to choose between setting
response.Text = string(lpResult.ResponseBody) and calling
sonic.Unmarshal(lpResult.ResponseBody, response), so both the plain-text branch
and the JSON-unmarshal branch consistently use the same detection logic; update
the code paths around where lpResult, request.Params, response and
sonic.Unmarshal are used to reference this new boolean.

🧹 Nitpick comments (3)

core/schemas/transcriptions.go (1)

29-40: Either make this helper OpenAI-specific, or include txt.

This package already defines TranscriptionExportOptionsTxt, but IsPlainTextTranscriptionFormat only matches "text", "srt", and "vtt". The current name reads provider-agnostic, so later reuse can silently miss a plain-text format.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@core/schemas/transcriptions.go` around lines 29 - 40, The helper
IsPlainTextTranscriptionFormat is provider-agnostic but currently omits the
package-defined TranscriptionExportOptionsTxt; update the function to either (A)
remain provider-agnostic and include "txt" in its switch (add case "txt"), or
(B) make it explicitly OpenAI-specific by renaming it (e.g.,
IsOpenAIPlainTextTranscriptionFormat) and documenting that it only checks
"text","srt","vtt"; modify callers accordingly to use the new name if you choose
option B. Ensure references to TranscriptionExportOptionsTxt are covered by the
chosen change.

transports/bifrost-http/integrations/router.go (1)

1069-1079: Add a regression test for this raw-byte bypass.

This early return is now the behavior that keeps text, srt, and vtt responses from being JSON-encoded again. A transport-level test that asserts the exact body bytes plus propagated Content-Type would make future refactors much safer.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@transports/bifrost-http/integrations/router.go` around lines 1069 - 1079, Add
a transport-level regression test that exercises the raw-byte bypass path when
the converter returns []byte: simulate a provider response for a text-format
transcription (e.g., "text", "srt", "vtt"), have the converter return a []byte
body and providerResponseHeaders including Content-Type, and assert that the
handler writes the exact raw bytes (ctx.SetBody) and sets the provider headers
on the response (ctx.Response.Header / Content-Type) without JSON-encoding;
target the code paths around the rawBytes type assertion and early return so
future refactors preserve this behavior.

core/providers/openai/openai.go (1)

2516-2516: Resolve the TODO in this parsing branch before merge.

Line 2516 leaves a known divergence in a response hot path; please either switch this branch to HandleProviderResponse now or track a linked follow-up issue.

I can draft the exact HandleProviderResponse integration patch if you want.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@core/providers/openai/openai.go` at line 2516, The TODO at the parsing branch
must be resolved by invoking the shared response handler: replace the "// TODO:
add HandleProviderResponse here" placeholder with a call to
HandleProviderResponse(...) from the current branch, passing the same response
object, provider metadata, and any parsed output/error values used in this
function so the unified post-processing path is executed; if immediate
integration isn't possible, add a linked follow-up issue reference and a clear
comment explaining which variables (the provider response, parsing result, and
error) need to be forwarded to HandleProviderResponse so the future patch can
wire it exactly.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Duplicate comments:
In `@core/providers/openai/openai.go`:
- Around line 2397-2399: Compute a single boolean like isPlainText before
deciding how to decode lpResult: set isPlainText = (request.Params != nil &&
schemas.IsPlainTextTranscriptionFormat(request.Params.ResponseFormat)) ||
fallback check (e.g., inspect lpResult.ContentType header for "text/plain" or
otherwise detect plain-text by attempting a safe sniff of
lpResult.ResponseBody). Then use that isPlainText to choose between setting
response.Text = string(lpResult.ResponseBody) and calling
sonic.Unmarshal(lpResult.ResponseBody, response), so both the plain-text branch
and the JSON-unmarshal branch consistently use the same detection logic; update
the code paths around where lpResult, request.Params, response and
sonic.Unmarshal are used to reference this new boolean.

---

Nitpick comments:
In `@core/providers/openai/openai.go`:
- Line 2516: The TODO at the parsing branch must be resolved by invoking the
shared response handler: replace the "// TODO: add HandleProviderResponse here"
placeholder with a call to HandleProviderResponse(...) from the current branch,
passing the same response object, provider metadata, and any parsed output/error
values used in this function so the unified post-processing path is executed; if
immediate integration isn't possible, add a linked follow-up issue reference and
a clear comment explaining which variables (the provider response, parsing
result, and error) need to be forwarded to HandleProviderResponse so the future
patch can wire it exactly.

In `@core/schemas/transcriptions.go`:
- Around line 29-40: The helper IsPlainTextTranscriptionFormat is
provider-agnostic but currently omits the package-defined
TranscriptionExportOptionsTxt; update the function to either (A) remain
provider-agnostic and include "txt" in its switch (add case "txt"), or (B) make
it explicitly OpenAI-specific by renaming it (e.g.,
IsOpenAIPlainTextTranscriptionFormat) and documenting that it only checks
"text","srt","vtt"; modify callers accordingly to use the new name if you choose
option B. Ensure references to TranscriptionExportOptionsTxt are covered by the
chosen change.

In `@transports/bifrost-http/integrations/router.go`:
- Around line 1069-1079: Add a transport-level regression test that exercises
the raw-byte bypass path when the converter returns []byte: simulate a provider
response for a text-format transcription (e.g., "text", "srt", "vtt"), have the
converter return a []byte body and providerResponseHeaders including
Content-Type, and assert that the handler writes the exact raw bytes
(ctx.SetBody) and sets the provider headers on the response (ctx.Response.Header
/ Content-Type) without JSON-encoding; target the code paths around the rawBytes
type assertion and early return so future refactors preserve this behavior.

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: dce07248-d95e-4c01-afc6-dee689a8279e

📥 Commits

Reviewing files that changed from the base of the PR and between 2f8d1a1 and 2d3c5f8.

📒 Files selected for processing (4)

• core/providers/openai/openai.go
• core/schemas/transcriptions.go
• transports/bifrost-http/integrations/openai.go
• transports/bifrost-http/integrations/router.go

[coderabbitai]

@sammaji Thanks for the explanation! The updated approach — having TranscriptionResponseConverter inspect the ResponseFormat field on BifrostTranscriptionResponse and return raw bytes for plain-text formats (text, srt, vtt), with the router forwarding those bytes along with provider headers — is clean and well-structured. Triggering a full review now.

✅ Actions performed

Full review triggered.

[coderabbitai]

♻️ Duplicate comments (1)

core/providers/openai/openai.go (1)

2397-2399: ⚠️ Potential issue | 🟠 Major

Plain-text detection is still too narrowly tied to request.Params.ResponseFormat.

At Line 2397 and Line 2494, plain-text handling only triggers when request.Params.ResponseFormat is set. If format reaches this handler through another path, Line 2502 can still try JSON unmarshal on plain text and fail.

Use this verification script to confirm all transcription request construction paths always populate request.Params.ResponseFormat before reaching this code:

#!/bin/bash
set -euo pipefail

echo "== Bifrost transcription request shape =="
rg -n --type=go 'type\s+BifrostTranscriptionRequest\s+struct|ResponseFormat|response_format|TranscriptionParameters'

echo
echo "== Callers of OpenAI transcription handler =="
rg -n --type=go 'HandleOpenAITranscriptionRequest\(|\.Transcription\('

echo
echo "== Construction/population sites for transcription request params =="
rg -n --type=go 'BifrostTranscriptionRequest|Params:\s*&?schemas\.TranscriptionParameters|ResponseFormat:'

Also applies to: 2494-2503

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@core/providers/openai/openai.go` around lines 2397 - 2399, Broaden plain-text
detection: in the block using request.Params.ResponseFormat, change the logic so
you attempt JSON unmarshal first when the format is not explicitly plain-text
and fall back to plain-text on unmarshal error; specifically, around the code
that references request.Params.ResponseFormat,
schemas.IsPlainTextTranscriptionFormat, sonic.Unmarshal, lpResult.ResponseBody
and response.Text, keep the existing explicit plain-text branch, but in the
other branch call sonic.Unmarshal into response and if it returns an error treat
the payload as plain text by assigning response.Text =
string(lpResult.ResponseBody); apply the identical change to the other
occurrence that currently only checks request.Params.ResponseFormat so any path
that reaches this handler without Params still correctly handles plain-text
payloads.

🧹 Nitpick comments (1)

transports/bifrost-http/integrations/openai.go (1)

461-470: Deduplicate transcription conversion logic to avoid divergence.

Both converters implement identical plain-text/raw-response fallback behavior. Extracting a shared helper will keep future fixes consistent.

♻️ Proposed refactor

+func convertOpenAITranscriptionResponse(resp *schemas.BifrostTranscriptionResponse) interface{} {
+	if schemas.IsPlainTextTranscriptionFormat(resp.ResponseFormat) {
+		return []byte(resp.Text)
+	}
+	if resp.ExtraFields.Provider == schemas.OpenAI && resp.ExtraFields.RawResponse != nil {
+		return resp.ExtraFields.RawResponse
+	}
+	return resp
+}
+
 ...
 		TranscriptionResponseConverter: func(ctx *schemas.BifrostContext, resp *schemas.BifrostTranscriptionResponse) (interface{}, error) {
-			if schemas.IsPlainTextTranscriptionFormat(resp.ResponseFormat) {
-				return []byte(resp.Text), nil
-			}
-			if resp.ExtraFields.Provider == schemas.OpenAI {
-				if resp.ExtraFields.RawResponse != nil {
-					return resp.ExtraFields.RawResponse, nil
-				}
-			}
-			return resp, nil
+			return convertOpenAITranscriptionResponse(resp), nil
 		},
 ...
 			TranscriptionResponseConverter: func(ctx *schemas.BifrostContext, resp *schemas.BifrostTranscriptionResponse) (interface{}, error) {
-				if schemas.IsPlainTextTranscriptionFormat(resp.ResponseFormat) {
-					return []byte(resp.Text), nil
-				}
-				if resp.ExtraFields.Provider == schemas.OpenAI {
-					if resp.ExtraFields.RawResponse != nil {
-						return resp.ExtraFields.RawResponse, nil
-					}
-				}
-				return resp, nil
+				return convertOpenAITranscriptionResponse(resp), nil
 			},

Also applies to: 858-867

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@transports/bifrost-http/integrations/openai.go` around lines 461 - 470,
Extract the duplicated plain-text/raw-response fallback logic into a single
helper function (e.g., convertTranscriptionResponse or
NormalizeTranscriptionResponse) and have both TranscriptionResponseConverter
callbacks call that helper; specifically, move the checks for
schemas.IsPlainTextTranscriptionFormat(resp.ResponseFormat),
resp.ExtraFields.Provider == schemas.OpenAI, and returning
resp.ExtraFields.RawResponse / []byte(resp.Text) into the helper and return resp
as the final fallback so both instances (the one at
TranscriptionResponseConverter and the other at lines ~858-867) use the same
implementation.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Duplicate comments:
In `@core/providers/openai/openai.go`:
- Around line 2397-2399: Broaden plain-text detection: in the block using
request.Params.ResponseFormat, change the logic so you attempt JSON unmarshal
first when the format is not explicitly plain-text and fall back to plain-text
on unmarshal error; specifically, around the code that references
request.Params.ResponseFormat, schemas.IsPlainTextTranscriptionFormat,
sonic.Unmarshal, lpResult.ResponseBody and response.Text, keep the existing
explicit plain-text branch, but in the other branch call sonic.Unmarshal into
response and if it returns an error treat the payload as plain text by assigning
response.Text = string(lpResult.ResponseBody); apply the identical change to the
other occurrence that currently only checks request.Params.ResponseFormat so any
path that reaches this handler without Params still correctly handles plain-text
payloads.

---

Nitpick comments:
In `@transports/bifrost-http/integrations/openai.go`:
- Around line 461-470: Extract the duplicated plain-text/raw-response fallback
logic into a single helper function (e.g., convertTranscriptionResponse or
NormalizeTranscriptionResponse) and have both TranscriptionResponseConverter
callbacks call that helper; specifically, move the checks for
schemas.IsPlainTextTranscriptionFormat(resp.ResponseFormat),
resp.ExtraFields.Provider == schemas.OpenAI, and returning
resp.ExtraFields.RawResponse / []byte(resp.Text) into the helper and return resp
as the final fallback so both instances (the one at
TranscriptionResponseConverter and the other at lines ~858-867) use the same
implementation.

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: 26673d36-65ba-4936-a16a-d9f76b9ec471

📥 Commits

Reviewing files that changed from the base of the PR and between 2f8d1a1 and 2d3c5f8.

📒 Files selected for processing (4)

• core/providers/openai/openai.go
• core/schemas/transcriptions.go
• transports/bifrost-http/integrations/openai.go
• transports/bifrost-http/integrations/router.go

[coderabbitai]

♻️ Duplicate comments (1)

core/providers/openai/openai.go (1)

2397-2399: ⚠️ Potential issue | 🟠 Major

Use a content-type fallback for plain-text detection.

At Line 2397 and Line 2494, plain-text mode only depends on request.Params.ResponseFormat. If that field is unset but the provider returns plain-text content-type, Line 2399/Line 2502 still attempts JSON unmarshal and fails. Please compute one isPlainText flag using both request format and response content-type, and reuse it in both branches.

Also applies to: 2494-2503

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@core/providers/openai/openai.go` around lines 2397 - 2399, Compute a single
boolean isPlainText (e.g., isPlainText := (request.Params != nil &&
schemas.IsPlainTextTranscriptionFormat(request.Params.ResponseFormat)) ||
strings.HasPrefix(strings.ToLower(lpResult.ContentType), "text/") ||
strings.Contains(strings.ToLower(lpResult.ContentType), "plain") ) before the
JSON-unmarshal branches and use that flag instead of only checking
request.Params.ResponseFormat; then in both places where you currently set
response.Text = string(lpResult.ResponseBody) or call sonic.Unmarshal(...,
response) (the branches around lpResult.ResponseBody and sonic.Unmarshal), use
isPlainText to choose plain-text assignment vs JSON unmarshal so responses with
plain text content-type are handled even when ResponseFormat is unset.

🧹 Nitpick comments (1)

core/providers/openai/openai.go (1)

2516-2516: Please resolve the TODO in this hot path.

Line 2516 leaves transcription response handling split between manual parsing and HandleProviderResponse. This should be implemented (or tracked explicitly) to avoid drift.

I can draft the HandleProviderResponse refactor for this block if you want.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@core/providers/openai/openai.go` at line 2516, The TODO indicates
transcription response handling is still done manually here instead of using
HandleProviderResponse; replace the manual parsing/branching at this hot path
with a call to HandleProviderResponse, passing the provider response, context
(request/req/ctx), and any needed metadata (e.g., model, request ID, and
original audio source), and ensure HandleProviderResponse returns the unified
transcription result or error that this caller expects; update any local code
that depended on the old manual parsing to consume the unified result (or
propagate errors) so the hot path uses HandleProviderResponse consistently and
avoid drift.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Duplicate comments:
In `@core/providers/openai/openai.go`:
- Around line 2397-2399: Compute a single boolean isPlainText (e.g., isPlainText
:= (request.Params != nil &&
schemas.IsPlainTextTranscriptionFormat(request.Params.ResponseFormat)) ||
strings.HasPrefix(strings.ToLower(lpResult.ContentType), "text/") ||
strings.Contains(strings.ToLower(lpResult.ContentType), "plain") ) before the
JSON-unmarshal branches and use that flag instead of only checking
request.Params.ResponseFormat; then in both places where you currently set
response.Text = string(lpResult.ResponseBody) or call sonic.Unmarshal(...,
response) (the branches around lpResult.ResponseBody and sonic.Unmarshal), use
isPlainText to choose plain-text assignment vs JSON unmarshal so responses with
plain text content-type are handled even when ResponseFormat is unset.

---

Nitpick comments:
In `@core/providers/openai/openai.go`:
- Line 2516: The TODO indicates transcription response handling is still done
manually here instead of using HandleProviderResponse; replace the manual
parsing/branching at this hot path with a call to HandleProviderResponse,
passing the provider response, context (request/req/ctx), and any needed
metadata (e.g., model, request ID, and original audio source), and ensure
HandleProviderResponse returns the unified transcription result or error that
this caller expects; update any local code that depended on the old manual
parsing to consume the unified result (or propagate errors) so the hot path uses
HandleProviderResponse consistently and avoid drift.

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: a3742135-c97d-4220-a173-5ad8e374cfab

📥 Commits

Reviewing files that changed from the base of the PR and between 2f8d1a1 and 2d3c5f8.

📒 Files selected for processing (4)

• core/providers/openai/openai.go
• core/schemas/transcriptions.go
• transports/bifrost-http/integrations/openai.go
• transports/bifrost-http/integrations/router.go

[coderabbitai]

🧹 Nitpick comments (1)

core/providers/openai/openai.go (1)

2519-2526: Replace this TODO with the shared response handler to avoid parser drift.

This JSON branch still does manual unmarshal/raw parsing. Converging on providerUtils.HandleProviderResponse will keep behavior aligned with other handlers and remove duplicated parsing logic.

♻️ Proposed refactor

-		// TODO: add HandleProviderResponse here
-
-		// Parse raw response for RawResponse field
-		if sendBackRawResponse {
-			if err := sonic.Unmarshal(copiedResponseBody, &rawResponse); err != nil {
-				return nil, providerUtils.NewBifrostOperationError(schemas.ErrProviderRawResponseUnmarshal, err, providerName)
-			}
-		}
+		_, rawResponse, bifrostErr = providerUtils.HandleProviderResponse(
+			copiedResponseBody,
+			response,
+			nil,
+			false,
+			sendBackRawResponse,
+		)
+		if bifrostErr != nil {
+			return nil, bifrostErr
+		}

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@core/providers/openai/openai.go` around lines 2519 - 2526, The manual raw
JSON parsing under the sendBackRawResponse branch should be replaced with the
shared handler: call providerUtils.HandleProviderResponse instead of
sonic.Unmarshal to parse copiedResponseBody into rawResponse and handle errors
consistently; update the surrounding code in openai.go to pass
copiedResponseBody, sendBackRawResponse, a pointer to rawResponse and
providerName into providerUtils.HandleProviderResponse and propagate any
returned error (instead of constructing providerUtils.NewBifrostOperationError
locally) so this code uses the centralized parsing/response logic.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Nitpick comments:
In `@core/providers/openai/openai.go`:
- Around line 2519-2526: The manual raw JSON parsing under the
sendBackRawResponse branch should be replaced with the shared handler: call
providerUtils.HandleProviderResponse instead of sonic.Unmarshal to parse
copiedResponseBody into rawResponse and handle errors consistently; update the
surrounding code in openai.go to pass copiedResponseBody, sendBackRawResponse, a
pointer to rawResponse and providerName into
providerUtils.HandleProviderResponse and propagate any returned error (instead
of constructing providerUtils.NewBifrostOperationError locally) so this code
uses the centralized parsing/response logic.

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: e45de41a-541c-48b1-9627-009f115658df

📥 Commits

Reviewing files that changed from the base of the PR and between 2d3c5f8 and 49fe4b9.

📒 Files selected for processing (4)

• core/providers/openai/openai.go
• core/schemas/transcriptions.go
• transports/bifrost-http/integrations/openai.go
• transports/bifrost-http/integrations/router.go

🚧 Files skipped from review as they are similar to previous changes (2)

• transports/bifrost-http/integrations/router.go
• transports/bifrost-http/integrations/openai.go

[coderabbitai]

Actionable comments posted: 2

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@core/providers/openai/openai.go`:
- Around line 2400-2402: The plain-text transcription branch currently sets
response.Text but doesn't preserve ExtraFields.RawResponse like the
large-payload path does; update the branch that checks
schemas.IsPlainTextTranscriptionFormat(request.Params.ResponseFormat) (and the
corresponding large-payload handling around lpResult.ResponseBody and
sonic.Unmarshal) to also set response.ExtraFields.RawResponse =
string(lpResult.ResponseBody) when sendBackRawResponse is enabled (or otherwise
mirror the same RawResponse assignment logic used in the large-payload path) so
RawResponse is consistent for both standard and large transcription flows.

In `@core/schemas/transcriptions.go`:
- Around line 29-36: The BackfillParams method currently checks the wrong
condition and can panic when req.Params is nil; change it so that after guarding
r and req for nil you first ensure req.Params is non-nil and then only assign
req.Params.ResponseFormat to r.ResponseFormat when r.ResponseFormat is nil
(i.e., invert the current condition) to avoid overwriting provider-populated
values and to prevent a nil dereference; locate the method BackfillParams on
type BifrostTranscriptionResponse and update the conditional logic that
references r.ResponseFormat and req.Params.ResponseFormat accordingly.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: 9cde90f6-47bb-45ed-a6ff-557e4f51019e

📥 Commits

Reviewing files that changed from the base of the PR and between 49fe4b9 and 399b52a.

📒 Files selected for processing (5)

• core/bifrost.go
• core/providers/openai/openai.go
• core/schemas/transcriptions.go
• transports/bifrost-http/integrations/openai.go
• transports/bifrost-http/integrations/router.go

🚧 Files skipped from review as they are similar to previous changes (2)

• transports/bifrost-http/integrations/router.go
• transports/bifrost-http/integrations/openai.go

[coderabbitai]

♻️ Duplicate comments (1)

core/providers/openai/openai.go (1)

2422-2424: ⚠️ Potential issue | 🟡 Minor

Keep the plain-text branches behaviorally identical.

Lines 2519-2521 preserve RawResponse, but Lines 2422-2424 only fill Text. Large text/srt/vtt transcriptions will therefore lose ExtraFields.RawResponse purely based on payload size. Mirroring the same assignment in the large-payload path — or extracting a tiny shared helper for both branches — will keep the two flows aligned.

🩹 Minimal fix

 		if len(lpResult.ResponseBody) > 0 {
 			response := &schemas.BifrostTranscriptionResponse{}
+			var rawResponse interface{}
 			if request.Params != nil && schemas.IsPlainTextTranscriptionFormat(request.Params.ResponseFormat) {
-				response.Text = string(lpResult.ResponseBody)
+				text := string(lpResult.ResponseBody)
+				response.Text = text
+				if sendBackRawResponse {
+					rawResponse = text
+				}
 			} else if err := sonic.Unmarshal(lpResult.ResponseBody, response); err != nil {
 				return nil, providerUtils.NewBifrostOperationError(schemas.ErrProviderResponseUnmarshal, err, providerName)
 			}
-			response.ExtraFields = schemas.BifrostResponseExtraFields{Provider: providerName, ModelRequested: request.Model, RequestType: schemas.TranscriptionRequest, Latency: lpResult.Latency}
+			response.ExtraFields = schemas.BifrostResponseExtraFields{
+				Provider:       providerName,
+				ModelRequested: request.Model,
+				RequestType:    schemas.TranscriptionRequest,
+				Latency:        lpResult.Latency,
+				RawResponse:    rawResponse,
+			}
 			return response, nil
 		}

Also applies to: 2517-2522

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@core/providers/openai/openai.go` around lines 2422 - 2424, The plain-text
transcription branch (where
schemas.IsPlainTextTranscriptionFormat(request.Params.ResponseFormat) is true)
only sets response.Text and therefore omits populating
response.ExtraFields.RawResponse like the large-payload path does; update the
plain-text branch in the openai provider so it mirrors the large-payload
behavior by assigning response.ExtraFields.RawResponse = lpResult.ResponseBody
(or refactor into a small helper used by both branches) before returning,
keeping the use of lpResult.ResponseBody and sonic.Unmarshal for the
non-plain-text branch unchanged.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Duplicate comments:
In `@core/providers/openai/openai.go`:
- Around line 2422-2424: The plain-text transcription branch (where
schemas.IsPlainTextTranscriptionFormat(request.Params.ResponseFormat) is true)
only sets response.Text and therefore omits populating
response.ExtraFields.RawResponse like the large-payload path does; update the
plain-text branch in the openai provider so it mirrors the large-payload
behavior by assigning response.ExtraFields.RawResponse = lpResult.ResponseBody
(or refactor into a small helper used by both branches) before returning,
keeping the use of lpResult.ResponseBody and sonic.Unmarshal for the
non-plain-text branch unchanged.

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: 874fee69-da94-4b9c-8de1-fb8cfa7a6b07

📥 Commits

Reviewing files that changed from the base of the PR and between 399b52a and f82d0ac.

📒 Files selected for processing (5)

• core/bifrost.go
• core/providers/openai/openai.go
• core/schemas/transcriptions.go
• transports/bifrost-http/integrations/openai.go
• transports/bifrost-http/integrations/router.go

🚧 Files skipped from review as they are similar to previous changes (3)

• transports/bifrost-http/integrations/openai.go
• core/bifrost.go
• core/schemas/transcriptions.go

[coderabbitai]

♻️ Duplicate comments (1)

core/providers/openai/openai.go (1)

2422-2427: ⚠️ Potential issue | 🟡 Minor

Preserve RawResponse in the large-payload plain-text path.

At Line 2422-Line 2427, plain-text LP responses set response.Text but never populate ExtraFields.RawResponse, while the standard path does this at Line 2519-Line 2521. sendBackRawResponse=true behaves differently based on payload path.

🩹 Proposed fix

 		if len(lpResult.ResponseBody) > 0 {
 			response := &schemas.BifrostTranscriptionResponse{}
+			var rawResponse interface{}
 			if request.Params != nil && schemas.IsPlainTextTranscriptionFormat(request.Params.ResponseFormat) {
 				response.Text = string(lpResult.ResponseBody)
+				if sendBackRawResponse {
+					rawResponse = response.Text
+				}
 			} else if err := sonic.Unmarshal(lpResult.ResponseBody, response); err != nil {
 				return nil, providerUtils.NewBifrostOperationError(schemas.ErrProviderResponseUnmarshal, err, providerName)
 			}
-			response.ExtraFields = schemas.BifrostResponseExtraFields{Provider: providerName, ModelRequested: request.Model, RequestType: schemas.TranscriptionRequest, Latency: lpResult.Latency}
+			response.ExtraFields = schemas.BifrostResponseExtraFields{
+				Provider:       providerName,
+				ModelRequested: request.Model,
+				RequestType:    schemas.TranscriptionRequest,
+				Latency:        lpResult.Latency,
+				RawResponse:    rawResponse,
+			}
 			return response, nil
 		}

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@core/providers/openai/openai.go` around lines 2422 - 2427, The plain-text
large-payload branch in the transcription path sets response.Text but never
populates response.ExtraFields.RawResponse, causing sendBackRawResponse to
differ from the normal path; update the plain-text branch in the same block that
uses schemas.IsPlainTextTranscriptionFormat(request.Params.ResponseFormat) to
populate response.ExtraFields (schemas.BifrostResponseExtraFields) with the same
fields used in the normal path and include RawResponse from
lpResult.ResponseBody (convert to the correct type expected by RawResponse,
e.g., string or json.RawMessage) alongside Provider, ModelRequested,
RequestType, and Latency so the raw payload is preserved.

🧹 Nitpick comments (1)

core/providers/openai/openai.go (1)

2539-2539: Track or resolve this TODO before it gets stale.

At Line 2539, please either complete the HandleProviderResponse migration now or attach an issue reference so this path doesn’t drift.

I can draft the follow-up issue (or the actual patch) if you want.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@core/providers/openai/openai.go` at line 2539, The TODO for
HandleProviderResponse must not be left unresolved—either implement the function
or attach an issue reference; locate the placeholder comment for
HandleProviderResponse in the openai provider (symbol: HandleProviderResponse)
and replace it with a concrete implementation that mirrors the project's
provider response contract (validate provider response, normalize fields, handle
errors/edge cases and return the expected response type), or if implementation
is deferred add a clear TODO with an issue URL/ID and a short comment describing
what the implementation must do (inputs, outputs, error handling) so the purpose
won’t drift.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Duplicate comments:
In `@core/providers/openai/openai.go`:
- Around line 2422-2427: The plain-text large-payload branch in the
transcription path sets response.Text but never populates
response.ExtraFields.RawResponse, causing sendBackRawResponse to differ from the
normal path; update the plain-text branch in the same block that uses
schemas.IsPlainTextTranscriptionFormat(request.Params.ResponseFormat) to
populate response.ExtraFields (schemas.BifrostResponseExtraFields) with the same
fields used in the normal path and include RawResponse from
lpResult.ResponseBody (convert to the correct type expected by RawResponse,
e.g., string or json.RawMessage) alongside Provider, ModelRequested,
RequestType, and Latency so the raw payload is preserved.

---

Nitpick comments:
In `@core/providers/openai/openai.go`:
- Line 2539: The TODO for HandleProviderResponse must not be left
unresolved—either implement the function or attach an issue reference; locate
the placeholder comment for HandleProviderResponse in the openai provider
(symbol: HandleProviderResponse) and replace it with a concrete implementation
that mirrors the project's provider response contract (validate provider
response, normalize fields, handle errors/edge cases and return the expected
response type), or if implementation is deferred add a clear TODO with an issue
URL/ID and a short comment describing what the implementation must do (inputs,
outputs, error handling) so the purpose won’t drift.

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: 65804c10-d84d-432d-a4e8-3ac2fcf6e5b6

📥 Commits

Reviewing files that changed from the base of the PR and between f82d0ac and 217b180.

📒 Files selected for processing (5)

• core/bifrost.go
• core/providers/openai/openai.go
• core/schemas/transcriptions.go
• transports/bifrost-http/integrations/openai.go
• transports/bifrost-http/integrations/router.go

✅ Files skipped from review due to trivial changes (1)

• core/bifrost.go

🚧 Files skipped from review as they are similar to previous changes (3)

• transports/bifrost-http/integrations/router.go
• core/schemas/transcriptions.go
• transports/bifrost-http/integrations/openai.go

[coderabbitai]

♻️ Duplicate comments (1)

core/schemas/transcriptions.go (1)

29-34: ⚠️ Potential issue | 🟠 Major

Prevent BackfillParams from clobbering provider-populated format.

Line 33 unconditionally assigns r.ResponseFormat, which can overwrite provider-set values and misroute downstream plain-text handling. Only backfill when r.ResponseFormat is nil.

💡 Proposed fix

func (r *BifrostTranscriptionResponse) BackfillParams(req *BifrostTranscriptionRequest) {
	if r == nil || req == nil || req.Params == nil || req.Params.ResponseFormat == nil {
		return
	}
-	r.ResponseFormat = req.Params.ResponseFormat
+	if r.ResponseFormat == nil {
+		r.ResponseFormat = req.Params.ResponseFormat
+	}
}

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@core/schemas/transcriptions.go` around lines 29 - 34, In
BifrostTranscriptionResponse.BackfillParams, avoid clobbering a provider-set
format by only assigning r.ResponseFormat from req.Params.ResponseFormat when
r.ResponseFormat is nil; check r.ResponseFormat == nil before setting it so
existing provider-populated values are preserved (referencing
BifrostTranscriptionResponse.BackfillParams,
BifrostTranscriptionResponse.ResponseFormat and
BifrostTranscriptionRequest.Params.ResponseFormat).

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Duplicate comments:
In `@core/schemas/transcriptions.go`:
- Around line 29-34: In BifrostTranscriptionResponse.BackfillParams, avoid
clobbering a provider-set format by only assigning r.ResponseFormat from
req.Params.ResponseFormat when r.ResponseFormat is nil; check r.ResponseFormat
== nil before setting it so existing provider-populated values are preserved
(referencing BifrostTranscriptionResponse.BackfillParams,
BifrostTranscriptionResponse.ResponseFormat and
BifrostTranscriptionRequest.Params.ResponseFormat).

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro

Run ID: 00df0cb0-94d7-41d0-9edd-f75538fe5d81

📥 Commits

Reviewing files that changed from the base of the PR and between 217b180 and 7f1c246.

📒 Files selected for processing (5)

• core/bifrost.go
• core/providers/openai/openai.go
• core/schemas/transcriptions.go
• transports/bifrost-http/integrations/openai.go
• transports/bifrost-http/integrations/router.go

✅ Files skipped from review due to trivial changes (2)

• core/bifrost.go
• core/providers/openai/openai.go

🚧 Files skipped from review as they are similar to previous changes (2)

• transports/bifrost-http/integrations/openai.go
• transports/bifrost-http/integrations/router.go