fix: reroute requests incoming from integrations for full compatibility in custom providers

TejasGhatte · TejasGhatte · commit 8dca6ec24ac3 · 2025-12-09T15:59:50.000+05:30
diff --git a/core/providers/anthropic/anthropic.go b/core/providers/anthropic/anthropic.go
@@ -308,6 +308,19 @@ func (provider *AnthropicProvider) TextCompletionStream(ctx context.Context, pos
 // Returns a BifrostResponse containing the completion results or an error if the request fails.
 func (provider *AnthropicProvider) ChatCompletion(ctx context.Context, key schemas.Key, request *schemas.BifrostChatRequest) (*schemas.BifrostChatResponse, *schemas.BifrostError) {
 	if err := providerUtils.CheckOperationAllowed(schemas.Anthropic, provider.customProviderConfig, schemas.ChatCompletionRequest); err != nil {
+		if _, ok := ctx.Value(schemas.BifrostContextKeyIntegrationRequest).(bool); ok {
+			responsesResponse, err := provider.Responses(ctx, key, request.ToResponsesRequest())
+			if err != nil {
+				return nil, err
+			}
+
+			response := responsesResponse.ToBifrostChatResponse()
+			response.ExtraFields.RequestType = schemas.ChatCompletionRequest
+			response.ExtraFields.Provider = provider.GetProviderKey()
+			response.ExtraFields.ModelRequested = request.Model
+
+			return response, nil
+		}
 		return nil, err
 	}
 
@@ -358,6 +371,10 @@ func (provider *AnthropicProvider) ChatCompletion(ctx context.Context, key schem
 // Returns a channel containing BifrostResponse objects representing the stream or an error if the request fails.
 func (provider *AnthropicProvider) ChatCompletionStream(ctx context.Context, postHookRunner schemas.PostHookRunner, key schemas.Key, request *schemas.BifrostChatRequest) (chan *schemas.BifrostStream, *schemas.BifrostError) {
 	if err := providerUtils.CheckOperationAllowed(schemas.Anthropic, provider.customProviderConfig, schemas.ChatCompletionStreamRequest); err != nil {
+		if _, ok := ctx.Value(schemas.BifrostContextKeyIntegrationRequest).(bool); ok {
+			ctx = context.WithValue(ctx, schemas.BifrostContextKeyIsChatCompletionToResponsesStreamFallback, true)
+			return provider.ResponsesStream(ctx, postHookRunner, key, request.ToResponsesRequest())
+		}
 		return nil, err
 	}
 
@@ -659,6 +676,19 @@ func HandleAnthropicChatCompletionStreaming(
 // Returns a BifrostResponse containing the completion results or an error if the request fails.
 func (provider *AnthropicProvider) Responses(ctx context.Context, key schemas.Key, request *schemas.BifrostResponsesRequest) (*schemas.BifrostResponsesResponse, *schemas.BifrostError) {
 	if err := providerUtils.CheckOperationAllowed(schemas.Anthropic, provider.customProviderConfig, schemas.ResponsesRequest); err != nil {
+		if _, ok := ctx.Value(schemas.BifrostContextKeyIntegrationRequest).(bool); ok {
+			chatResponse, err := provider.ChatCompletion(ctx, key, request.ToChatRequest())
+			if err != nil {
+				return nil, err
+			}
+
+			response := chatResponse.ToBifrostResponsesResponse()
+			response.ExtraFields.RequestType = schemas.ResponsesRequest
+			response.ExtraFields.Provider = provider.GetProviderKey()
+			response.ExtraFields.ModelRequested = request.Model
+
+			return response, nil
+		}
 		return nil, err
 	}
 
@@ -707,6 +737,15 @@ func (provider *AnthropicProvider) Responses(ctx context.Context, key schemas.Ke
 // ResponsesStream performs a streaming responses request to the Anthropic API.
 func (provider *AnthropicProvider) ResponsesStream(ctx context.Context, postHookRunner schemas.PostHookRunner, key schemas.Key, request *schemas.BifrostResponsesRequest) (chan *schemas.BifrostStream, *schemas.BifrostError) {
 	if err := providerUtils.CheckOperationAllowed(schemas.Anthropic, provider.customProviderConfig, schemas.ResponsesStreamRequest); err != nil {
+		if _, ok := ctx.Value(schemas.BifrostContextKeyIntegrationRequest).(bool); ok {
+			ctx = context.WithValue(ctx, schemas.BifrostContextKeyIsResponsesToChatCompletionFallback, true)
+			return provider.ChatCompletionStream(
+				ctx,
+				postHookRunner,
+				key,
+				request.ToChatRequest(),
+			)
+		}
 		return nil, err
 	}
 
diff --git a/core/providers/bedrock/bedrock.go b/core/providers/bedrock/bedrock.go
@@ -663,6 +663,19 @@ func (provider *BedrockProvider) TextCompletionStream(ctx context.Context, postH
 // Returns a BifrostResponse containing the completion results or an error if the request fails.
 func (provider *BedrockProvider) ChatCompletion(ctx context.Context, key schemas.Key, request *schemas.BifrostChatRequest) (*schemas.BifrostChatResponse, *schemas.BifrostError) {
 	if err := providerUtils.CheckOperationAllowed(schemas.Bedrock, provider.customProviderConfig, schemas.ChatCompletionRequest); err != nil {
+		if _, ok := ctx.Value(schemas.BifrostContextKeyIntegrationRequest).(bool); ok {
+			responsesResponse, err := provider.Responses(ctx, key, request.ToResponsesRequest())
+			if err != nil {
+				return nil, err
+			}
+
+			response := responsesResponse.ToBifrostChatResponse()
+			response.ExtraFields.RequestType = schemas.ChatCompletionRequest
+			response.ExtraFields.Provider = provider.GetProviderKey()
+			response.ExtraFields.ModelRequested = request.Model
+
+			return response, nil
+		}
 		return nil, err
 	}
 
@@ -729,6 +742,10 @@ func (provider *BedrockProvider) ChatCompletion(ctx context.Context, key schemas
 // Returns a channel for streaming BifrostResponse objects or an error if the request fails.
 func (provider *BedrockProvider) ChatCompletionStream(ctx context.Context, postHookRunner schemas.PostHookRunner, key schemas.Key, request *schemas.BifrostChatRequest) (chan *schemas.BifrostStream, *schemas.BifrostError) {
 	if err := providerUtils.CheckOperationAllowed(schemas.Bedrock, provider.customProviderConfig, schemas.ChatCompletionStreamRequest); err != nil {
+		if _, ok := ctx.Value(schemas.BifrostContextKeyIntegrationRequest).(bool); ok {
+			ctx = context.WithValue(ctx, schemas.BifrostContextKeyIsChatCompletionToResponsesStreamFallback, true)
+			return provider.ResponsesStream(ctx, postHookRunner, key, request.ToResponsesRequest())
+		}
 		return nil, err
 	}
 
@@ -891,6 +908,19 @@ func (provider *BedrockProvider) ChatCompletionStream(ctx context.Context, postH
 // Returns a BifrostResponse containing the completion results or an error if the request fails.
 func (provider *BedrockProvider) Responses(ctx context.Context, key schemas.Key, request *schemas.BifrostResponsesRequest) (*schemas.BifrostResponsesResponse, *schemas.BifrostError) {
 	if err := providerUtils.CheckOperationAllowed(schemas.Bedrock, provider.customProviderConfig, schemas.ResponsesRequest); err != nil {
+		if _, ok := ctx.Value(schemas.BifrostContextKeyIntegrationRequest).(bool); ok {
+			chatResponse, err := provider.ChatCompletion(ctx, key, request.ToChatRequest())
+			if err != nil {
+				return nil, err
+			}
+
+			response := chatResponse.ToBifrostResponsesResponse()
+			response.ExtraFields.RequestType = schemas.ResponsesRequest
+			response.ExtraFields.Provider = provider.GetProviderKey()
+			response.ExtraFields.ModelRequested = request.Model
+
+			return response, nil
+		}
 		return nil, err
 	}
 
@@ -959,6 +989,15 @@ func (provider *BedrockProvider) Responses(ctx context.Context, key schemas.Key,
 // Returns a channel for streaming BifrostResponse objects or an error if the request fails.
 func (provider *BedrockProvider) ResponsesStream(ctx context.Context, postHookRunner schemas.PostHookRunner, key schemas.Key, request *schemas.BifrostResponsesRequest) (chan *schemas.BifrostStream, *schemas.BifrostError) {
 	if err := providerUtils.CheckOperationAllowed(schemas.Bedrock, provider.customProviderConfig, schemas.ResponsesStreamRequest); err != nil {
+		if _, ok := ctx.Value(schemas.BifrostContextKeyIntegrationRequest).(bool); ok {
+			ctx = context.WithValue(ctx, schemas.BifrostContextKeyIsResponsesToChatCompletionFallback, true)
+			return provider.ChatCompletionStream(
+				ctx,
+				postHookRunner,
+				key,
+				request.ToChatRequest(),
+			)
+		}
 		return nil, err
 	}
 
diff --git a/core/providers/cohere/cohere.go b/core/providers/cohere/cohere.go
@@ -288,6 +288,19 @@ func (provider *CohereProvider) TextCompletionStream(ctx context.Context, postHo
 func (provider *CohereProvider) ChatCompletion(ctx context.Context, key schemas.Key, request *schemas.BifrostChatRequest) (*schemas.BifrostChatResponse, *schemas.BifrostError) {
 	// Check if chat completion is allowed
 	if err := providerUtils.CheckOperationAllowed(schemas.Cohere, provider.customProviderConfig, schemas.ChatCompletionRequest); err != nil {
+		if _, ok := ctx.Value(schemas.BifrostContextKeyIntegrationRequest).(bool); ok {
+			responsesResponse, err := provider.Responses(ctx, key, request.ToResponsesRequest())
+			if err != nil {
+				return nil, err
+			}
+
+			response := responsesResponse.ToBifrostChatResponse()
+			response.ExtraFields.RequestType = schemas.ChatCompletionRequest
+			response.ExtraFields.Provider = provider.GetProviderKey()
+			response.ExtraFields.ModelRequested = request.Model
+
+			return response, nil
+		}
 		return nil, err
 	}
 
@@ -337,6 +350,10 @@ func (provider *CohereProvider) ChatCompletion(ctx context.Context, key schemas.
 func (provider *CohereProvider) ChatCompletionStream(ctx context.Context, postHookRunner schemas.PostHookRunner, key schemas.Key, request *schemas.BifrostChatRequest) (chan *schemas.BifrostStream, *schemas.BifrostError) {
 	// Check if chat completion stream is allowed
 	if err := providerUtils.CheckOperationAllowed(schemas.Cohere, provider.customProviderConfig, schemas.ChatCompletionStreamRequest); err != nil {
+		if _, ok := ctx.Value(schemas.BifrostContextKeyIntegrationRequest).(bool); ok {
+			ctx = context.WithValue(ctx, schemas.BifrostContextKeyIsChatCompletionToResponsesStreamFallback, true)
+			return provider.ResponsesStream(ctx, postHookRunner, key, request.ToResponsesRequest())
+		}
 		return nil, err
 	}
 
@@ -504,6 +521,19 @@ func (provider *CohereProvider) ChatCompletionStream(ctx context.Context, postHo
 func (provider *CohereProvider) Responses(ctx context.Context, key schemas.Key, request *schemas.BifrostResponsesRequest) (*schemas.BifrostResponsesResponse, *schemas.BifrostError) {
 	// Check if chat completion is allowed
 	if err := providerUtils.CheckOperationAllowed(schemas.Cohere, provider.customProviderConfig, schemas.ResponsesRequest); err != nil {
+		if _, ok := ctx.Value(schemas.BifrostContextKeyIntegrationRequest).(bool); ok {
+			chatResponse, err := provider.ChatCompletion(ctx, key, request.ToChatRequest())
+			if err != nil {
+				return nil, err
+			}
+
+			response := chatResponse.ToBifrostResponsesResponse()
+			response.ExtraFields.RequestType = schemas.ResponsesRequest
+			response.ExtraFields.Provider = provider.GetProviderKey()
+			response.ExtraFields.ModelRequested = request.Model
+
+			return response, nil
+		}
 		return nil, err
 	}
 
@@ -553,6 +583,15 @@ func (provider *CohereProvider) Responses(ctx context.Context, key schemas.Key,
 func (provider *CohereProvider) ResponsesStream(ctx context.Context, postHookRunner schemas.PostHookRunner, key schemas.Key, request *schemas.BifrostResponsesRequest) (chan *schemas.BifrostStream, *schemas.BifrostError) {
 	// Check if responses stream is allowed
 	if err := providerUtils.CheckOperationAllowed(schemas.Cohere, provider.customProviderConfig, schemas.ResponsesStreamRequest); err != nil {
+		if _, ok := ctx.Value(schemas.BifrostContextKeyIntegrationRequest).(bool); ok {
+			ctx = context.WithValue(ctx, schemas.BifrostContextKeyIsResponsesToChatCompletionFallback, true)
+			return provider.ChatCompletionStream(
+				ctx,
+				postHookRunner,
+				key,
+				request.ToChatRequest(),
+			)
+		}
 		return nil, err
 	}
 
diff --git a/core/providers/openai/openai.go b/core/providers/openai/openai.go
@@ -580,6 +580,19 @@ func HandleOpenAITextCompletionStreaming(
 func (provider *OpenAIProvider) ChatCompletion(ctx context.Context, key schemas.Key, request *schemas.BifrostChatRequest) (*schemas.BifrostChatResponse, *schemas.BifrostError) {
 	// Check if chat completion is allowed for this provider
 	if err := providerUtils.CheckOperationAllowed(schemas.OpenAI, provider.customProviderConfig, schemas.ChatCompletionRequest); err != nil {
+		if _, ok := ctx.Value(schemas.BifrostContextKeyIntegrationRequest).(bool); ok {
+			responsesResponse, err := provider.Responses(ctx, key, request.ToResponsesRequest())
+			if err != nil {
+				return nil, err
+			}
+
+			response := responsesResponse.ToBifrostChatResponse()
+			response.ExtraFields.RequestType = schemas.ChatCompletionRequest
+			response.ExtraFields.Provider = provider.GetProviderKey()
+			response.ExtraFields.ModelRequested = request.Model
+
+			return response, nil
+		}
 		return nil, err
 	}
 
@@ -680,6 +693,10 @@ func HandleOpenAIChatCompletionRequest(
 func (provider *OpenAIProvider) ChatCompletionStream(ctx context.Context, postHookRunner schemas.PostHookRunner, key schemas.Key, request *schemas.BifrostChatRequest) (chan *schemas.BifrostStream, *schemas.BifrostError) {
 	// Check if chat completion stream is allowed for this provider
 	if err := providerUtils.CheckOperationAllowed(schemas.OpenAI, provider.customProviderConfig, schemas.ChatCompletionStreamRequest); err != nil {
+		if _, ok := ctx.Value(schemas.BifrostContextKeyIntegrationRequest).(bool); ok {
+			ctx = context.WithValue(ctx, schemas.BifrostContextKeyIsChatCompletionToResponsesStreamFallback, true)
+			return provider.ResponsesStream(ctx, postHookRunner, key, request.ToResponsesRequest())
+		}
 		return nil, err
 	}
 	var authHeader map[string]string
@@ -1042,6 +1059,19 @@ func HandleOpenAIChatCompletionStreaming(
 func (provider *OpenAIProvider) Responses(ctx context.Context, key schemas.Key, request *schemas.BifrostResponsesRequest) (*schemas.BifrostResponsesResponse, *schemas.BifrostError) {
 	// Check if chat completion is allowed for this provider
 	if err := providerUtils.CheckOperationAllowed(schemas.OpenAI, provider.customProviderConfig, schemas.ResponsesRequest); err != nil {
+		if _, ok := ctx.Value(schemas.BifrostContextKeyIntegrationRequest).(bool); ok {
+			chatResponse, err := provider.ChatCompletion(ctx, key, request.ToChatRequest())
+			if err != nil {
+				return nil, err
+			}
+
+			response := chatResponse.ToBifrostResponsesResponse()
+			response.ExtraFields.RequestType = schemas.ResponsesRequest
+			response.ExtraFields.Provider = provider.GetProviderKey()
+			response.ExtraFields.ModelRequested = request.Model
+
+			return response, nil
+		}
 		return nil, err
 	}
 
@@ -1141,6 +1171,15 @@ func HandleOpenAIResponsesRequest(
 func (provider *OpenAIProvider) ResponsesStream(ctx context.Context, postHookRunner schemas.PostHookRunner, key schemas.Key, request *schemas.BifrostResponsesRequest) (chan *schemas.BifrostStream, *schemas.BifrostError) {
 	// Check if chat completion stream is allowed for this provider
 	if err := providerUtils.CheckOperationAllowed(schemas.OpenAI, provider.customProviderConfig, schemas.ResponsesStreamRequest); err != nil {
+		if _, ok := ctx.Value(schemas.BifrostContextKeyIntegrationRequest).(bool); ok {
+			ctx = context.WithValue(ctx, schemas.BifrostContextKeyIsResponsesToChatCompletionFallback, true)
+			return provider.ChatCompletionStream(
+				ctx,
+				postHookRunner,
+				key,
+				request.ToChatRequest(),
+			)
+		}
 		return nil, err
 	}
 	var authHeader map[string]string
diff --git a/core/schemas/bifrost.go b/core/schemas/bifrost.go
@@ -102,21 +102,23 @@ type BifrostContextKey string
 
 // BifrostContextKeyRequestType is a context key for the request type.
 const (
-	BifrostContextKeyVirtualKey                          BifrostContextKey = "x-bf-vk"                                          // string
-	BifrostContextKeyRequestID                           BifrostContextKey = "request-id"                                       // string
-	BifrostContextKeyFallbackRequestID                   BifrostContextKey = "fallback-request-id"                              // string
-	BifrostContextKeyDirectKey                           BifrostContextKey = "bifrost-direct-key"                               // Key struct
-	BifrostContextKeySelectedKeyID                       BifrostContextKey = "bifrost-selected-key-id"                          // string (to store the selected key ID (set by bifrost))
-	BifrostContextKeySelectedKeyName                     BifrostContextKey = "bifrost-selected-key-name"                        // string (to store the selected key name (set by bifrost))
-	BifrostContextKeyNumberOfRetries                     BifrostContextKey = "bifrost-number-of-retries"                        // int (to store the number of retries (set by bifrost))
-	BifrostContextKeyFallbackIndex                       BifrostContextKey = "bifrost-fallback-index"                           // int (to store the fallback index (set by bifrost)) 0 for primary, 1 for first fallback, etc.
-	BifrostContextKeyStreamEndIndicator                  BifrostContextKey = "bifrost-stream-end-indicator"                     // bool (set by bifrost)
-	BifrostContextKeySkipKeySelection                    BifrostContextKey = "bifrost-skip-key-selection"                       // bool (will pass an empty key to the provider)
-	BifrostContextKeyExtraHeaders                        BifrostContextKey = "bifrost-extra-headers"                            // map[string]string
-	BifrostContextKeyURLPath                             BifrostContextKey = "bifrost-extra-url-path"                           // string
-	BifrostContextKeyUseRawRequestBody                   BifrostContextKey = "bifrost-use-raw-request-body"                     // bool
-	BifrostContextKeySendBackRawResponse                 BifrostContextKey = "bifrost-send-back-raw-response"                   // bool
-	BifrostContextKeyIsResponsesToChatCompletionFallback BifrostContextKey = "bifrost-is-responses-to-chat-completion-fallback" // bool (set by bifrost)
+	BifrostContextKeyVirtualKey                                BifrostContextKey = "x-bf-vk"                                                 // string
+	BifrostContextKeyRequestID                                 BifrostContextKey = "request-id"                                              // string
+	BifrostContextKeyFallbackRequestID                         BifrostContextKey = "fallback-request-id"                                     // string
+	BifrostContextKeyDirectKey                                 BifrostContextKey = "bifrost-direct-key"                                      // Key struct
+	BifrostContextKeyIntegrationRequest                        BifrostContextKey = "bifrost-integration-request"                             // bool (set by bifrost)
+	BifrostContextKeySelectedKeyID                             BifrostContextKey = "bifrost-selected-key-id"                                 // string (to store the selected key ID (set by bifrost))
+	BifrostContextKeySelectedKeyName                           BifrostContextKey = "bifrost-selected-key-name"                               // string (to store the selected key name (set by bifrost))
+	BifrostContextKeyNumberOfRetries                           BifrostContextKey = "bifrost-number-of-retries"                               // int (to store the number of retries (set by bifrost))
+	BifrostContextKeyFallbackIndex                             BifrostContextKey = "bifrost-fallback-index"                                  // int (to store the fallback index (set by bifrost)) 0 for primary, 1 for first fallback, etc.
+	BifrostContextKeyStreamEndIndicator                        BifrostContextKey = "bifrost-stream-end-indicator"                            // bool (set by bifrost)
+	BifrostContextKeySkipKeySelection                          BifrostContextKey = "bifrost-skip-key-selection"                              // bool (will pass an empty key to the provider)
+	BifrostContextKeyExtraHeaders                              BifrostContextKey = "bifrost-extra-headers"                                   // map[string]string
+	BifrostContextKeyURLPath                                   BifrostContextKey = "bifrost-extra-url-path"                                  // string
+	BifrostContextKeyUseRawRequestBody                         BifrostContextKey = "bifrost-use-raw-request-body"                            // bool
+	BifrostContextKeySendBackRawResponse                       BifrostContextKey = "bifrost-send-back-raw-response"                          // bool
+	BifrostContextKeyIsResponsesToChatCompletionFallback       BifrostContextKey = "bifrost-is-responses-to-chat-completion-fallback"        // bool (set by bifrost)
+	BifrostContextKeyIsChatCompletionToResponsesStreamFallback BifrostContextKey = "bifrost-is-chat-completion-to-responses-stream-fallback" // bool (set by bifrost)
 )
 
 // NOTE: for custom plugin implementation dealing with streaming short circuit,
diff --git a/transports/bifrost-http/integrations/router.go b/transports/bifrost-http/integrations/router.go
