fix kwargs implementation

Author: fm1320

adalflow/adalflow/components/model_client/openai_client.py

@@ -106,6 +106,12 @@ class OpenAIClient(ModelClient):
     Users (1) simplify use ``Embedder`` and ``Generator`` components by passing OpenAIClient() as the model_client.
     (2) can use this as an example to create their own API client or extend this class(copying and modifing the code) in their own project.
 
+    Args:
+        api_key (Optional[str], optional): OpenAI API key. Defaults to None.
+        chat_completion_parser (Callable[[Completion], Any], optional): A function to parse the chat completion to a str. Defaults to None.
+        input_type (Literal["text", "messages"], optional): The type of input to use. Defaults to "text".
+        model_type (ModelType, optional): The type of model to use (EMBEDDER, LLM, or IMAGE_GENERATION). Defaults to ModelType.LLM.
+
     Note:
         We suggest users not to use `response_format` to enforce output data type or `tools` and `tool_choice`  in your model_kwargs when calling the API.
         We do not know how OpenAI is doing the formating or what prompt they have added.
@@ -120,14 +126,9 @@ class OpenAIClient(ModelClient):
         - prompt: Text description of the image to generate
         - size: "1024x1024", "1024x1792", or "1792x1024" for DALL-E 3; "256x256", "512x512", or "1024x1024" for DALL-E 2
         - quality: "standard" or "hd" (DALL-E 3 only)
-        - n: Number of images to generate (1 for DALL-E 3, 1-10 for DALL-E 2)
+        - n: Number of images (1 for DALL-E 3, 1-10 for DALL-E 2)
         - response_format: "url" or "b64_json"
 
-    Args:
-        api_key (Optional[str], optional): OpenAI API key. Defaults to None.
-        chat_completion_parser (Callable[[Completion], Any], optional): A function to parse the chat completion to a str. Defaults to None.
-            Default is `get_first_message_content`.
-
     References:
         - Embeddings models: https://platform.openai.com/docs/guides/embeddings
         - Chat models: https://platform.openai.com/docs/guides/text-generation
@@ -141,11 +142,15 @@ def __init__(
         api_key: Optional[str] = None,
         chat_completion_parser: Callable[[Completion], Any] = None,
         input_type: Literal["text", "messages"] = "text",
+        model_type: ModelType = ModelType.LLM,
     ):
         r"""It is recommended to set the OPENAI_API_KEY environment variable instead of passing it as an argument.
 
         Args:
             api_key (Optional[str], optional): OpenAI API key. Defaults to None.
+            chat_completion_parser (Callable[[Completion], Any], optional): A function to parse the chat completion to a str. Defaults to None.
+            input_type (Literal["text", "messages"], optional): The type of input to use. Defaults to "text".
+            model_type (ModelType, optional): The type of model to use (EMBEDDER, LLM, or IMAGE_GENERATION). Defaults to ModelType.LLM.
         """
         super().__init__()
         self._api_key = api_key
@@ -155,6 +160,7 @@ def __init__(
             chat_completion_parser or get_first_message_content
         )
         self._input_type = input_type
+        self.model_type = model_type
 
     def init_sync_client(self):
         api_key = self._api_key or os.getenv("OPENAI_API_KEY")
@@ -229,7 +235,6 @@ def convert_inputs_to_api_kwargs(
         self,
         input: Optional[Any] = None,
         model_kwargs: Dict = {},
-        model_type: ModelType = ModelType.UNDEFINED,
     ) -> Dict:
         r"""
         Specify the API input type and output api_kwargs that will be used in _call and _acall methods.
@@ -254,21 +259,20 @@ def convert_inputs_to_api_kwargs(
                 - mask: Path to the mask image
                 For variations (DALL-E 2 only):
                 - image: Path to the input image
-            model_type: The type of model (EMBEDDER, LLM, or IMAGE_GENERATION)
 
         Returns:
             Dict: API-specific kwargs for the model call
         """
 
         final_model_kwargs = model_kwargs.copy()
-        if model_type == ModelType.EMBEDDER:
+        if self.model_type == ModelType.EMBEDDER:
             if isinstance(input, str):
                 input = [input]
             # convert input to input
             if not isinstance(input, Sequence):
                 raise TypeError("input must be a sequence of text")
             final_model_kwargs["input"] = input
-        elif model_type == ModelType.LLM:
+        elif self.model_type == ModelType.LLM:
             # convert input to messages
             messages: List[Dict[str, str]] = []
             images = final_model_kwargs.pop("images", None)
@@ -313,7 +317,7 @@ def convert_inputs_to_api_kwargs(
                 else:
                     messages.append({"role": "system", "content": input})
             final_model_kwargs["messages"] = messages
-        elif model_type == ModelType.IMAGE_GENERATION:
+        elif self.model_type == ModelType.IMAGE_GENERATION:
             # For image generation, input is the prompt
             final_model_kwargs["prompt"] = input
             # Ensure model is specified
@@ -358,7 +362,7 @@ def convert_inputs_to_api_kwargs(
             else:
                 raise ValueError(f"Invalid operation: {operation}")
         else:
-            raise ValueError(f"model_type {model_type} is not supported")
+            raise ValueError(f"model_type {self.model_type} is not supported")
         return final_model_kwargs
 
     def parse_image_generation_response(self, response: List[Image]) -> GeneratorOutput:

adalflow/adalflow/core/generator.py

@@ -70,21 +70,11 @@ class Generator(GradComponent, CachedEngine, CallbackManager):
         template (Optional[str], optional): The template for the prompt.  Defaults to :ref:`DEFAULT_ADALFLOW_SYSTEM_PROMPT<core-default_prompt_template>`.
         prompt_kwargs (Optional[Dict], optional): The preset prompt kwargs to fill in the variables in the prompt. Defaults to None.
         output_processors (Optional[Component], optional):  The output processors after model call. It can be a single component or a chained component via ``Sequential``. Defaults to None.
-        trainable_params (Optional[List[str]], optional): The list of trainable parameters. Defaults to [].
-
-    Note:
-        The output_processors will be applied to the string output of the model completion. And the result will be stored in the data field of the output.
-        And we encourage you to only use it to parse the response to data format you will use later.
+        name (Optional[str], optional): The name of the generator. Defaults to None.
+        cache_path (Optional[str], optional): The path to save the cache. Defaults to None.
+        use_cache (bool, optional): Whether to use cache. Defaults to False.
     """
 
-    model_type: ModelType = ModelType.LLM
-    model_client: ModelClient  # for better type checking
-
-    _use_cache: bool = False
-    _kwargs: Dict[str, Any] = (
-        {}
-    )  # to create teacher generator from student TODO: might reaccess this
-
     def __init__(
         self,
         *,
@@ -100,8 +90,6 @@ def __init__(
         # args for the cache
         cache_path: Optional[str] = None,
         use_cache: bool = False,
-        # args for model type
-        model_type: ModelType = ModelType.LLM,
     ) -> None:
         r"""The default prompt is set to the DEFAULT_ADALFLOW_SYSTEM_PROMPT. It has the following variables:
         - task_desc_str
@@ -112,17 +100,6 @@ def __init__(
         - steps_str
         You can preset the prompt kwargs to fill in the variables in the prompt using prompt_kwargs.
         But you can replace the prompt and set any variables you want and use the prompt_kwargs to fill in the variables.
-
-        Args:
-            model_client (ModelClient): The model client to use for the generator.
-            model_kwargs (Dict[str, Any], optional): The model kwargs to pass to the model client. Defaults to {}. Please refer to :ref:`ModelClient<components-model_client>` for the details on how to set the model_kwargs for your specific model if it is from our library.
-            template (Optional[str], optional): The template for the prompt.  Defaults to :ref:`DEFAULT_ADALFLOW_SYSTEM_PROMPT<core-default_prompt_template>`.
-            prompt_kwargs (Optional[Dict], optional): The preset prompt kwargs to fill in the variables in the prompt. Defaults to None.
-            output_processors (Optional[Component], optional):  The output processors after model call. It can be a single component or a chained component via ``Sequential``. Defaults to None.
-            name (Optional[str], optional): The name of the generator. Defaults to None.
-            cache_path (Optional[str], optional): The path to save the cache. Defaults to None.
-            use_cache (bool, optional): Whether to use cache. Defaults to False.
-            model_type (ModelType, optional): The type of model (EMBEDDER, LLM, or IMAGE_GENERATION). Defaults to ModelType.LLM.
         """
 
         if not isinstance(model_client, ModelClient):
@@ -134,7 +111,6 @@ def __init__(
         template = template or DEFAULT_ADALFLOW_SYSTEM_PROMPT
 
         # create the cache path and initialize the cache engine
-
         self.set_cache_path(
             cache_path, model_client, model_kwargs.get("model", "default")
         )
@@ -146,7 +122,7 @@ def __init__(
         CallbackManager.__init__(self)
 
         self.name = name or self.__class__.__name__
-        self.model_type = model_type
+        self.model_type = model_client.model_type  # Get model type from client
 
         self._init_prompt(template, prompt_kwargs)
 
@@ -177,7 +153,6 @@ def __init__(
             "name": name,
             "cache_path": cache_path,
             "use_cache": use_cache,
-            "model_type": model_type,
         }
         self._teacher: Optional["Generator"] = None
         self._trace_api_kwargs: Dict[str, Any] = (
@@ -351,7 +326,6 @@ def _pre_call(self, prompt_kwargs: Dict, model_kwargs: Dict) -> Dict[str, Any]:
         api_kwargs = self.model_client.convert_inputs_to_api_kwargs(
             input=prompt_str,
             model_kwargs=composed_model_kwargs,
-            model_type=self.model_type,
         )
         return api_kwargs
 

tutorials/multimodal_client_testing_examples.py

@@ -25,7 +25,7 @@
 
 def test_basic_generation():
     """Test basic text generation"""
-    client = OpenAIClient()
+    client = OpenAIClient()  # Default model_type is LLM
     gen = Generator(
         model_client=client,
         model_kwargs={
@@ -40,7 +40,7 @@ def test_basic_generation():
 
 def test_invalid_image_url():
     """Test Generator output with invalid image URL"""
-    client = OpenAIClient()
+    client = OpenAIClient()  # Default model_type is LLM
     gen = Generator(
         model_client=client,
         model_kwargs={
@@ -56,16 +56,15 @@ def test_invalid_image_url():
 
 def test_invalid_image_generation():
     """Test DALL-E generation with invalid parameters"""
-    client = OpenAIClient()
+    client = OpenAIClient(model_type=ModelType.IMAGE_GENERATION)
     gen = Generator(
         model_client=client,
         model_kwargs={
             "model": "dall-e-3",
             "size": "invalid_size",  # Invalid size parameter
             "quality": "standard",
             "n": 1
-        },
-        model_type=ModelType.IMAGE_GENERATION
+        }
     )
 
     print("\n=== Testing Invalid DALL-E Parameters ===")
@@ -74,11 +73,10 @@ def test_invalid_image_generation():
 
 def test_vision_and_generation():
     """Test both vision analysis and image generation"""
-    client = OpenAIClient()
-    
-    # 1. Test Vision Analysis
+    # 1. Test Vision Analysis with LLM client
+    vision_client = OpenAIClient()  # Default model_type is LLM
     vision_gen = Generator(
-        model_client=client,
+        model_client=vision_client,
         model_kwargs={
             "model": "gpt-4o-mini",
             "images": "https://upload.wikimedia.org/wikipedia/en/7/7d/Lenna_%28test_image%29.png",
@@ -90,16 +88,16 @@ def test_vision_and_generation():
     print("\n=== Vision Analysis ===")
     print(f"Description: {vision_response.raw_response}")
 
-    # 2. Test DALL-E Image Generation
+    # 2. Test DALL-E Image Generation with IMAGE_GENERATION client
+    dalle_client = OpenAIClient(model_type=ModelType.IMAGE_GENERATION)
     dalle_gen = Generator(
-        model_client=client,
+        model_client=dalle_client,
         model_kwargs={
             "model": "dall-e-3",
             "size": "1024x1024",
             "quality": "standard",
             "n": 1
-        },
-        model_type=ModelType.IMAGE_GENERATION
+        }
     )
 
     # For image generation, input_str becomes the prompt