first commit

core/providers/openai/transcription.go

@@ -0,0 +1,117 @@
+package openai
+
+import (
+	"fmt"
+	"mime/multipart"
+
+	"github.com/maximhq/bifrost/core/providers/utils"
+	"github.com/maximhq/bifrost/core/schemas"
+)
+
+// ToBifrostTranscriptionRequest converts an OpenAI transcription request to Bifrost format
+func (request *OpenAITranscriptionRequest) ToBifrostTranscriptionRequest(ctx *schemas.BifrostContext) *schemas.BifrostTranscriptionRequest {
+	provider, model := schemas.ParseModelString(request.Model, utils.CheckAndSetDefaultProvider(ctx, schemas.OpenAI))
+
+	return &schemas.BifrostTranscriptionRequest{
+		Provider: provider,
+		Model:    model,
+		Input: &schemas.TranscriptionInput{
+			File: request.File,
+		},
+		Params:    &request.TranscriptionParameters,
+		Fallbacks: schemas.ParseFallbacks(request.Fallbacks),
+	}
+}
+
+// ToOpenAITranscriptionRequest converts a Bifrost transcription request to OpenAI format
+func ToOpenAITranscriptionRequest(bifrostReq *schemas.BifrostTranscriptionRequest) *OpenAITranscriptionRequest {
+	if bifrostReq == nil || bifrostReq.Input.File == nil {
+		return nil
+	}
+
+	transcriptionInput := bifrostReq.Input
+	params := bifrostReq.Params
+
+	openaiReq := &OpenAITranscriptionRequest{
+		Model:    bifrostReq.Model,
+		File:     transcriptionInput.File,
+		Filename: transcriptionInput.Filename,
+	}
+
+	if params != nil {
+		openaiReq.TranscriptionParameters = *params
+	}
+
+	return openaiReq
+}
+
+// ParseTranscriptionFormDataBodyFromRequest parses the transcription request and writes it to the multipart form.
+func ParseTranscriptionFormDataBodyFromRequest(writer *multipart.Writer, openaiReq *OpenAITranscriptionRequest, providerName schemas.ModelProvider) *schemas.BifrostError {
+	// Add model field before the file so upstreams can route without buffering the audio payload.
+	if err := writer.WriteField("model", openaiReq.Model); err != nil {
+		return utils.NewBifrostOperationError("failed to write model field", err)
+	}
+
+	// Add optional fields
+	if openaiReq.Language != nil {
+		if err := writer.WriteField("language", *openaiReq.Language); err != nil {
+			return utils.NewBifrostOperationError("failed to write language field", err)
+		}
+	}
+
+	if openaiReq.Prompt != nil {
+		if err := writer.WriteField("prompt", *openaiReq.Prompt); err != nil {
+			return utils.NewBifrostOperationError("failed to write prompt field", err)
+		}
+	}
+
+	if openaiReq.ResponseFormat != nil {
+		if err := writer.WriteField("response_format", *openaiReq.ResponseFormat); err != nil {
+			return utils.NewBifrostOperationError("failed to write response_format field", err)
+		}
+	}
+
+	if openaiReq.Temperature != nil {
+		if err := writer.WriteField("temperature", fmt.Sprintf("%g", *openaiReq.Temperature)); err != nil {
+			return utils.NewBifrostOperationError("failed to write temperature field", err)
+		}
+	}
+
+	for _, granularity := range openaiReq.TimestampGranularities {
+		if err := writer.WriteField("timestamp_granularities[]", granularity); err != nil {
+			return utils.NewBifrostOperationError("failed to write timestamp_granularities field", err)
+		}
+	}
+
+	for _, include := range openaiReq.Include {
+		if err := writer.WriteField("include[]", include); err != nil {
+			return utils.NewBifrostOperationError("failed to write include field", err)
+		}
+	}
+
+	if openaiReq.Stream != nil && *openaiReq.Stream {
+		if err := writer.WriteField("stream", "true"); err != nil {
+			return utils.NewBifrostOperationError("failed to write stream field", err)
+		}
+	}
+
+	// Add file field last so large multipart uploads don't block model discovery upstream.
+	filename := openaiReq.Filename
+	if filename == "" {
+		filename = utils.AudioFilenameFromBytes(openaiReq.File)
+	}
+	fileWriter, err := writer.CreateFormFile("file", filename)
+	if err != nil {
+		return utils.NewBifrostOperationError("failed to create form file", err)
+	}
+	if _, err := fileWriter.Write(openaiReq.File); err != nil {
+		return utils.NewBifrostOperationError("failed to write file data", err)
+	}
+
+	// Close the multipart writer
+	if err := writer.Close(); err != nil {
+		return utils.NewBifrostOperationError("failed to close multipart writer", err)
+	}
+
+	return nil
+}