return OpenAIDenseEmbedder(
            model_name=self.dense.model,
            api_key=self.dense.api_key,
            api_base=self.dense.api_base,
            dimension=self.dense.dimension,
            context=context,
        )
        ...
        return JinaDenseEmbedder(
            model_name=self.dense.model,
            api_key=self.dense.api_key,
            api_base=self.dense.api_base,
            dimension=self.dense.dimension,
            context=context,
        )

in XXXEmbedder impl:

  class OpenAIDenseEmbedder:
    ...
    input_type = "x" if context == "query" else "y"

  class JinaDenseEmbedder:
    ...
    task  = "a" if context == "query" else "b"

would this be better?

I've moved the context parameter handling into embedder classes:

OpenAIDenseEmbedder:

def __init__(self, ..., context: Optional[str] = None, query_param: Optional[str] = None, document_param: Optional[str] = None, ...):
    non_symmetric = query_param is not None or document_param is not None
    if not non_symmetric:
        self.input_type = None
    elif context == "query":
        self.input_type = query_param if query_param is not None else "query"
    elif context == "document":
        self.input_type = document_param if document_param is not None else "passage"

JinaDenseEmbedder:

def __init__(self, ..., context: Optional[str] = None, query_param: str = "retrieval.query", document_param: str = "retrieval.passage", ...):
    if context == "query":
        self.task = query_param
    elif context == "document":
        self.task = document_param

Each embedder class now decides how to handle the context parameter - OpenAI uses input_type, Jina uses task. The _get_contextual_embedder() now simply passes the context parameter to the embedder class without provider-specific if/else logic.

too many config fields here.

1. input_type_query, task_query refers to the same thing, should use same config name
2. i don't think query / document / retrieval.query / retrieval.passage need to be set in config. static value should be decided by each Embedder for each context.

I've consolidated the config fields!

Removed 4 old fields:

• input_type_query
• input_type_document
• task_query
• task_document

Added 2 unified fields:

• query_param - works for all providers (OpenAI → input_type, Jina → task)
• document_param - works for all providers

This makes it easier to add new providers in the future - no need to add new config fields, just use the existing query_param/document_param. The embedder class decides the default values:

• OpenAI: query_param defaults to "query", document_param defaults to "passage"
• Jina: query_param defaults to "retrieval.query", document_param defaults to "retrieval.passage"

OpenAI embedder is set default as symmetric models (without query_param and document_param in config). For OpenAI-Compatible embedding providers, if the user set one of the querry_param or document_param, the non-symmetric mode will be on. Users can specify the query_param and document_param to override the default value.

btw, just to confirm, OpenAI itself doesn't support input_type, but OpenAI compatible embedding models might require this in extra body to set query / document type?

how do we determine what's the key in extraBody ? e.g. input_type, task_type etc.

yes, OpenAI models are symmetric, this param is designed for OpenAI compatible embedding APIs.

Official OpenAI models:

• Symmetric, do not support input_type parameter
• Examples: text-embedding-3-small, text-embedding-3-large

OpenAI-compatible third-party models:

• May require input_type parameter for non-symmetric embeddings
• Examples: Jina, Cohere, Voyage

How to determine the key in extra_body:

• Each embedder class decides which key to use
• OpenAIDenseEmbedder uses input_type
• JinaDenseEmbedder uses task

This is documented in the class docstrings:

"""OpenAI-Compatible Dense Embedder Implementation

Note: Official OpenAI models are symmetric and do not support the input_type parameter.
Non-symmetric mode (context='query'/'document') is only supported by OpenAI-compatible
third-party models (e.g., BGE-M3, Jina, Cohere, etc.) that implement the input_type parameter.
"""