kagent-adk 0.6.8__tar.gz → 0.6.9__tar.gz

{kagent_adk-0.6.8 → kagent_adk-0.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kagent-adk
-Version: 0.6.8
+Version: 0.6.9
 Summary: kagent-adk is an sdk for integrating adk agents with kagent
 Requires-Python: >=3.12.11
 Requires-Dist: a2a-sdk>=0.3.1

{kagent_adk-0.6.8 → kagent_adk-0.6.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "kagent-adk"
-version = "0.6.8"
+version = "0.6.9"
 description = "kagent-adk is an sdk for integrating adk agents with kagent"
 readme = "README.md"
 requires-python = ">=3.12.11"
@@ -50,3 +50,8 @@ packages = ["src/kagent"]
 
 [tool.ruff]
 extend = "../../pyproject.toml"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_default_fixture_loop_scope = "function"
+asyncio_mode = "auto"

{kagent_adk-0.6.8 → kagent_adk-0.6.9}/src/kagent/adk/__init__.py

@@ -1,7 +1,7 @@
 import importlib.metadata
 
 from ._a2a import KAgentApp
-from .models import AgentConfig
+from .types import AgentConfig
 
 __version__ = importlib.metadata.version("kagent_adk")
 

kagent_adk-0.6.9/src/kagent/adk/models/__init__.py

@@ -0,0 +1,3 @@
+from ._openai import AzureOpenAI, OpenAI
+
+__all__ = ["OpenAI", "AzureOpenAI"]

kagent_adk-0.6.9/src/kagent/adk/models/_openai.py

@@ -0,0 +1,393 @@
+from __future__ import annotations
+
+import base64
+import json
+import os
+from functools import cached_property
+from typing import TYPE_CHECKING, Any, AsyncGenerator, Iterable, Literal, Optional
+
+from google.adk.models import BaseLlm
+from google.adk.models.llm_response import LlmResponse
+from google.genai import types
+from openai import AsyncAzureOpenAI, AsyncOpenAI
+from openai.types.chat import (
+    ChatCompletion,
+    ChatCompletionAssistantMessageParam,
+    ChatCompletionContentPartImageParam,
+    ChatCompletionContentPartTextParam,
+    ChatCompletionMessageParam,
+    ChatCompletionSystemMessageParam,
+    ChatCompletionToolMessageParam,
+    ChatCompletionToolParam,
+    ChatCompletionUserMessageParam,
+)
+from openai.types.chat.chat_completion_message_tool_call_param import (
+    ChatCompletionMessageToolCallParam,
+)
+from openai.types.chat.chat_completion_message_tool_call_param import (
+    Function as ToolCallFunction,
+)
+from openai.types.shared_params import FunctionDefinition
+from pydantic import Field
+
+if TYPE_CHECKING:
+    from google.adk.models.llm_request import LlmRequest
+
+
+def _convert_role_to_openai(role: Optional[str]) -> str:
+    """Convert google.genai role to OpenAI role."""
+    if role in ["model", "assistant"]:
+        return "assistant"
+    elif role == "system":
+        return "system"
+    else:
+        return "user"
+
+
+def _convert_content_to_openai_messages(
+    contents: list[types.Content], system_instruction: Optional[str] = None
+) -> list[ChatCompletionMessageParam]:
+    """Convert google.genai Content list to OpenAI messages format."""
+    messages: list[ChatCompletionMessageParam] = []
+
+    # Add system message if provided
+    if system_instruction:
+        system_message: ChatCompletionSystemMessageParam = {"role": "system", "content": system_instruction}
+        messages.append(system_message)
+
+    # Track tool calls to ensure proper flow
+    pending_tool_calls = set()
+
+    for content in contents:
+        role = _convert_role_to_openai(content.role)
+
+        # Separate different types of parts
+        text_parts = []
+        function_calls = []
+        function_responses = []
+        image_parts = []
+
+        for part in content.parts or []:
+            if part.text:
+                text_parts.append(part.text)
+            elif part.function_call:
+                function_calls.append(part)
+            elif part.function_response:
+                function_responses.append(part)
+            elif part.inline_data and part.inline_data.mime_type and part.inline_data.mime_type.startswith("image"):
+                if part.inline_data.data:
+                    image_data = base64.b64encode(part.inline_data.data).decode()
+                    image_part: ChatCompletionContentPartImageParam = {
+                        "type": "image_url",
+                        "image_url": {"url": f"data:{part.inline_data.mime_type};base64,{image_data}"},
+                    }
+                    image_parts.append(image_part)
+
+        # Handle function responses first (they should be tool messages)
+        for func_response in function_responses:
+            tool_call_id = func_response.function_response.id or "call_1"
+            if tool_call_id in pending_tool_calls:
+                tool_message: ChatCompletionToolMessageParam = {
+                    "role": "tool",
+                    "tool_call_id": tool_call_id,
+                    "content": str(func_response.function_response.response.get("result", ""))
+                    if func_response.function_response.response
+                    else "",
+                }
+                messages.append(tool_message)
+                pending_tool_calls.discard(tool_call_id)
+
+        # Handle function calls (assistant messages with tool_calls)
+        if function_calls:
+            tool_calls = []
+            for func_call in function_calls:
+                tool_call_function: ToolCallFunction = {
+                    "name": func_call.function_call.name or "",
+                    "arguments": str(func_call.function_call.args) if func_call.function_call.args else "{}",
+                }
+                tool_call_id = func_call.function_call.id or "call_1"
+                tool_call: ChatCompletionMessageToolCallParam = {
+                    "id": tool_call_id,
+                    "type": "function",
+                    "function": tool_call_function,
+                }
+                tool_calls.append(tool_call)
+                pending_tool_calls.add(tool_call_id)
+
+            # Create assistant message with tool calls
+            text_content = "\n".join(text_parts) if text_parts else None
+            assistant_message: ChatCompletionAssistantMessageParam = {
+                "role": "assistant",
+                "content": text_content,
+                "tool_calls": tool_calls,
+            }
+            messages.append(assistant_message)
+
+        # Handle regular text/image messages (only if no function calls)
+        elif text_parts or image_parts:
+            if role == "user":
+                if image_parts and text_parts:
+                    # Multi-modal content
+                    text_part: ChatCompletionContentPartTextParam = {"type": "text", "text": "\n".join(text_parts)}
+                    content_parts = [text_part] + image_parts
+                    user_message: ChatCompletionUserMessageParam = {"role": "user", "content": content_parts}
+                elif image_parts:
+                    # Image only
+                    user_message: ChatCompletionUserMessageParam = {"role": "user", "content": image_parts}
+                else:
+                    # Text only
+                    user_message: ChatCompletionUserMessageParam = {"role": "user", "content": "\n".join(text_parts)}
+                messages.append(user_message)
+            elif role == "assistant":
+                # Assistant messages with text (no tool calls)
+                assistant_message: ChatCompletionAssistantMessageParam = {
+                    "role": "assistant",
+                    "content": "\n".join(text_parts),
+                }
+                messages.append(assistant_message)
+
+    return messages
+
+
+def _update_type_string(value_dict: dict[str, Any]):
+    """Updates 'type' field to expected JSON schema format."""
+    if "type" in value_dict:
+        value_dict["type"] = value_dict["type"].lower()
+
+    if "items" in value_dict:
+        # 'type' field could exist for items as well, this would be the case if
+        # items represent primitive types.
+        _update_type_string(value_dict["items"])
+
+        if "properties" in value_dict["items"]:
+            # There could be properties as well on the items, especially if the items
+            # are complex object themselves. We recursively traverse each individual
+            # property as well and fix the "type" value.
+            for _, value in value_dict["items"]["properties"].items():
+                _update_type_string(value)
+
+    if "properties" in value_dict:
+        # Handle nested properties
+        for _, value in value_dict["properties"].items():
+            _update_type_string(value)
+
+
+def _convert_tools_to_openai(tools: list[types.Tool]) -> list[ChatCompletionToolParam]:
+    """Convert google.genai Tools to OpenAI tools format."""
+    openai_tools: list[ChatCompletionToolParam] = []
+
+    for tool in tools:
+        if tool.function_declarations:
+            for func_decl in tool.function_declarations:
+                # Build function definition
+                function_def: FunctionDefinition = {
+                    "name": func_decl.name or "",
+                    "description": func_decl.description or "",
+                }
+
+                # Always include parameters field, even if empty
+                properties = {}
+                required = []
+
+                if func_decl.parameters:
+                    if func_decl.parameters.properties:
+                        for prop_name, prop_schema in func_decl.parameters.properties.items():
+                            value_dict = prop_schema.model_dump(exclude_none=True)
+                            _update_type_string(value_dict)
+                            properties[prop_name] = value_dict
+
+                    if func_decl.parameters.required:
+                        required = func_decl.parameters.required
+
+                function_def["parameters"] = {"type": "object", "properties": properties, "required": required}
+
+                # Create the tool param
+                openai_tool: ChatCompletionToolParam = {"type": "function", "function": function_def}
+                openai_tools.append(openai_tool)
+
+    return openai_tools
+
+
+def _convert_openai_response_to_llm_response(response: ChatCompletion) -> LlmResponse:
+    """Convert OpenAI response to LlmResponse."""
+    choice = response.choices[0]
+    message = choice.message
+
+    parts = []
+
+    # Handle text content
+    if message.content:
+        parts.append(types.Part.from_text(text=message.content))
+
+    # Handle function calls
+    if hasattr(message, "tool_calls") and message.tool_calls:
+        for tool_call in message.tool_calls:
+            if tool_call.type == "function":
+                try:
+                    args = json.loads(tool_call.function.arguments) if tool_call.function.arguments else {}
+                except json.JSONDecodeError:
+                    args = {}
+
+                part = types.Part.from_function_call(name=tool_call.function.name, args=args)
+                if part.function_call:
+                    part.function_call.id = tool_call.id
+                parts.append(part)
+
+    content = types.Content(role="model", parts=parts)
+
+    # Handle usage metadata
+    usage_metadata = None
+    if hasattr(response, "usage") and response.usage:
+        usage_metadata = types.GenerateContentResponseUsageMetadata(
+            prompt_token_count=response.usage.prompt_tokens,
+            candidates_token_count=response.usage.completion_tokens,
+            total_token_count=response.usage.total_tokens,
+        )
+
+    # Handle finish reason
+    finish_reason = types.FinishReason.STOP
+    if choice.finish_reason == "length":
+        finish_reason = types.FinishReason.MAX_TOKENS
+    elif choice.finish_reason == "content_filter":
+        finish_reason = types.FinishReason.SAFETY
+
+    return LlmResponse(content=content, usage_metadata=usage_metadata, finish_reason=finish_reason)
+
+
+class BaseOpenAI(BaseLlm):
+    """Base class for OpenAI-compatible models."""
+
+    model: str
+    base_url: Optional[str] = None
+    api_key: Optional[str] = Field(default=None, exclude=True)
+    max_tokens: Optional[int] = None
+    temperature: Optional[float] = None
+
+    @classmethod
+    def supported_models(cls) -> list[str]:
+        """Returns a list of supported models in regex for LlmRegistry."""
+        return [r"gpt-.*", r"o1-.*"]
+
+    @cached_property
+    def _client(self) -> AsyncOpenAI:
+        """Get the OpenAI client."""
+        kwargs = {}
+        if self.base_url:
+            kwargs["base_url"] = self.base_url
+        if self.api_key:
+            kwargs["api_key"] = self.api_key
+
+        return AsyncOpenAI(**kwargs)
+
+    async def generate_content_async(
+        self, llm_request: LlmRequest, stream: bool = False
+    ) -> AsyncGenerator[LlmResponse, None]:
+        """Generate content using OpenAI API."""
+
+        # Convert messages
+        system_instruction = None
+        if llm_request.config and llm_request.config.system_instruction:
+            if isinstance(llm_request.config.system_instruction, str):
+                system_instruction = llm_request.config.system_instruction
+            elif hasattr(llm_request.config.system_instruction, "parts"):
+                # Handle Content type system instruction
+                text_parts = []
+                parts = getattr(llm_request.config.system_instruction, "parts", [])
+                if parts:
+                    for part in parts:
+                        if hasattr(part, "text") and part.text:
+                            text_parts.append(part.text)
+                    system_instruction = "\n".join(text_parts)
+
+        messages = _convert_content_to_openai_messages(llm_request.contents, system_instruction)
+
+        # Prepare request parameters
+        kwargs = {
+            "model": llm_request.model or self.model,
+            "messages": messages,
+        }
+
+        if self.max_tokens:
+            kwargs["max_tokens"] = self.max_tokens
+        if self.temperature is not None:
+            kwargs["temperature"] = self.temperature
+
+        # Handle tools
+        if llm_request.config and llm_request.config.tools:
+            # Filter to only google.genai.types.Tool objects
+            genai_tools = []
+            for tool in llm_request.config.tools:
+                if hasattr(tool, "function_declarations"):
+                    genai_tools.append(tool)
+
+            if genai_tools:
+                openai_tools = _convert_tools_to_openai(genai_tools)
+                if openai_tools:
+                    kwargs["tools"] = openai_tools
+                    kwargs["tool_choice"] = "auto"
+
+        try:
+            if stream:
+                # Handle streaming
+                async for chunk in await self._client.chat.completions.create(stream=True, **kwargs):
+                    if chunk.choices and chunk.choices[0].delta:
+                        delta = chunk.choices[0].delta
+                        if delta.content:
+                            content = types.Content(role="model", parts=[types.Part.from_text(text=delta.content)])
+                            yield LlmResponse(
+                                content=content, partial=True, turn_complete=chunk.choices[0].finish_reason is not None
+                            )
+            else:
+                # Handle non-streaming
+                response = await self._client.chat.completions.create(stream=False, **kwargs)
+                yield _convert_openai_response_to_llm_response(response)
+
+        except Exception as e:
+            yield LlmResponse(error_code="API_ERROR", error_message=str(e))
+
+
+class OpenAI(BaseOpenAI):
+    """OpenAI model implementation."""
+
+    type: Literal["openai"]
+
+    @cached_property
+    def _client(self) -> AsyncOpenAI:
+        """Get the OpenAI client."""
+        kwargs = {}
+        if self.base_url:
+            kwargs["base_url"] = self.base_url
+        if self.api_key:
+            kwargs["api_key"] = self.api_key
+        elif "OPENAI_API_KEY" in os.environ:
+            kwargs["api_key"] = os.environ["OPENAI_API_KEY"]
+
+        return AsyncOpenAI(**kwargs)
+
+
+class AzureOpenAI(BaseOpenAI):
+    """Azure OpenAI model implementation."""
+
+    type: Literal["azure_openai"]
+    api_version: Optional[str] = None
+    azure_endpoint: Optional[str] = None
+    azure_deployment: Optional[str] = None
+
+    @cached_property
+    def _client(self) -> AsyncAzureOpenAI:
+        """Get the Azure OpenAI client."""
+        api_version = self.api_version or os.environ.get("AZURE_OPENAI_API_VERSION", "2024-02-15-preview")
+        azure_endpoint = self.azure_endpoint or os.environ.get("AZURE_OPENAI_ENDPOINT")
+        api_key = self.api_key or os.environ.get("AZURE_OPENAI_API_KEY")
+
+        if not azure_endpoint:
+            raise ValueError(
+                "Azure endpoint must be provided either via azure_endpoint parameter or AZURE_OPENAI_ENDPOINT environment variable"
+            )
+
+        if not api_key:
+            raise ValueError(
+                "API key must be provided either via api_key parameter or AZURE_OPENAI_API_KEY environment variable"
+            )
+
+        return AsyncAzureOpenAI(api_version=api_version, azure_endpoint=azure_endpoint, api_key=api_key)

kagent_adk-0.6.8/src/kagent/adk/models.py → kagent_adk-0.6.9/src/kagent/adk/types.py

@@ -12,6 +12,9 @@ from google.adk.tools.agent_tool import AgentTool
 from google.adk.tools.mcp_tool import MCPToolset, SseConnectionParams, StreamableHTTPConnectionParams
 from pydantic import BaseModel, Field
 
+from .models import AzureOpenAI as OpenAIAzure
+from .models import OpenAI as OpenAINative
+
 logger = logging.getLogger(__name__)
 
 
@@ -97,7 +100,7 @@ class AgentConfig(BaseModel):
                 mcp_toolsets.append(AgentTool(agent=remote_agent, skip_summarization=True))
 
         if self.model.type == "openai":
-            model = LiteLlm(model=f"openai/{self.model.model}", base_url=self.model.base_url)
+            model = OpenAINative(model=self.model.model, base_url=self.model.base_url, type="openai")
         elif self.model.type == "anthropic":
             model = LiteLlm(model=f"anthropic/{self.model.model}", base_url=self.model.base_url)
         elif self.model.type == "gemini_vertex_ai":
@@ -107,7 +110,7 @@ class AgentConfig(BaseModel):
         elif self.model.type == "ollama":
             model = LiteLlm(model=f"ollama_chat/{self.model.model}")
         elif self.model.type == "azure_openai":
-            model = LiteLlm(model=f"azure/{self.model.model}")
+            model = OpenAIAzure(model=self.model.model, type="azure_openai")
         elif self.model.type == "gemini":
             model = self.model.model
         else:

kagent_adk-0.6.9/tests/unittests/models/test_openai.py

@@ -0,0 +1,338 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from unittest import mock
+
+import pytest
+from google.adk.models.llm_request import LlmRequest
+from google.adk.models.llm_response import LlmResponse
+from google.genai import types
+from google.genai.types import Content, Part
+from openai.types.chat.chat_completion_tool_param import ChatCompletionToolParam
+
+from kagent.adk.models import OpenAI
+from kagent.adk.models._openai import _convert_tools_to_openai
+
+
+@pytest.fixture
+def generate_content_response():
+    # Create a mock response object
+    class MockUsage:
+        def __init__(self):
+            self.completion_tokens = 12
+            self.prompt_tokens = 13
+            self.total_tokens = 25
+
+    class MockMessage:
+        def __init__(self):
+            self.content = "Hi! How can I help you today?"
+            self.role = "assistant"
+
+    class MockChoice:
+        def __init__(self):
+            self.finish_reason = "stop"
+            self.index = 0
+            self.message = MockMessage()
+
+    class MockResponse:
+        def __init__(self):
+            self.id = "chatcmpl-testid"
+            self.choices = [MockChoice()]
+            self.created = 1234567890
+            self.model = "gpt-3.5-turbo"
+            self.object = "chat.completion"
+            self.usage = MockUsage()
+
+    return MockResponse()
+
+
+@pytest.fixture
+def generate_llm_response():
+    return LlmResponse.create(
+        types.GenerateContentResponse(
+            candidates=[
+                types.Candidate(
+                    content=Content(
+                        role="model",
+                        parts=[Part.from_text(text="Hello, how can I help you?")],
+                    ),
+                    finish_reason=types.FinishReason.STOP,
+                )
+            ]
+        )
+    )
+
+
+@pytest.fixture
+def openai_llm():
+    return OpenAI(model="gpt-3.5-turbo", type="openai")
+
+
+@pytest.fixture
+def llm_request():
+    return LlmRequest(
+        model="gpt-3.5-turbo",
+        contents=[Content(role="user", parts=[Part.from_text(text="Hello")])],
+        config=types.GenerateContentConfig(
+            temperature=0.1,
+            response_modalities=[types.Modality.TEXT],
+            system_instruction="You are a helpful assistant",
+        ),
+    )
+
+
+def test_supported_models():
+    models = OpenAI.supported_models()
+    assert len(models) == 2
+    assert models[0] == r"gpt-.*"
+    assert models[1] == r"o1-.*"
+
+
+function_declaration_test_cases = [
+    (
+        "function_with_no_parameters",
+        types.FunctionDeclaration(
+            name="get_current_time",
+            description="Gets the current time.",
+        ),
+        ChatCompletionToolParam(
+            type="function",
+            function={
+                "name": "get_current_time",
+                "description": "Gets the current time.",
+                "parameters": {"type": "object", "properties": {}, "required": []},
+            },
+        ),
+    ),
+    (
+        "function_with_one_optional_parameter",
+        types.FunctionDeclaration(
+            name="get_weather",
+            description="Gets weather information for a given location.",
+            parameters=types.Schema(
+                type=types.Type.OBJECT,
+                properties={
+                    "location": types.Schema(
+                        type=types.Type.STRING,
+                        description="City and state, e.g., San Francisco, CA",
+                    )
+                },
+            ),
+        ),
+        ChatCompletionToolParam(
+            type="function",
+            function={
+                "name": "get_weather",
+                "description": "Gets weather information for a given location.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "location": {
+                            "type": "string",
+                            "description": "City and state, e.g., San Francisco, CA",
+                        }
+                    },
+                    "required": [],
+                },
+            },
+        ),
+    ),
+    (
+        "function_with_one_required_parameter",
+        types.FunctionDeclaration(
+            name="get_stock_price",
+            description="Gets the current price for a stock ticker.",
+            parameters=types.Schema(
+                type=types.Type.OBJECT,
+                properties={
+                    "ticker": types.Schema(
+                        type=types.Type.STRING,
+                        description="The stock ticker, e.g., AAPL",
+                    )
+                },
+                required=["ticker"],
+            ),
+        ),
+        ChatCompletionToolParam(
+            type="function",
+            function={
+                "name": "get_stock_price",
+                "description": "Gets the current price for a stock ticker.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "ticker": {
+                            "type": "string",
+                            "description": "The stock ticker, e.g., AAPL",
+                        }
+                    },
+                    "required": ["ticker"],
+                },
+            },
+        ),
+    ),
+    (
+        "function_with_multiple_mixed_parameters",
+        types.FunctionDeclaration(
+            name="submit_order",
+            description="Submits a product order.",
+            parameters=types.Schema(
+                type=types.Type.OBJECT,
+                properties={
+                    "product_id": types.Schema(type=types.Type.STRING, description="The product ID"),
+                    "quantity": types.Schema(
+                        type=types.Type.INTEGER,
+                        description="The order quantity",
+                    ),
+                    "notes": types.Schema(
+                        type=types.Type.STRING,
+                        description="Optional order notes",
+                    ),
+                },
+                required=["product_id", "quantity"],
+            ),
+        ),
+        ChatCompletionToolParam(
+            type="function",
+            function={
+                "name": "submit_order",
+                "description": "Submits a product order.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "product_id": {
+                            "type": "string",
+                            "description": "The product ID",
+                        },
+                        "quantity": {
+                            "type": "integer",
+                            "description": "The order quantity",
+                        },
+                        "notes": {
+                            "type": "string",
+                            "description": "Optional order notes",
+                        },
+                    },
+                    "required": ["product_id", "quantity"],
+                },
+            },
+        ),
+    ),
+    (
+        "function_with_complex_nested_parameter",
+        types.FunctionDeclaration(
+            name="create_playlist",
+            description="Creates a playlist from a list of songs.",
+            parameters=types.Schema(
+                type=types.Type.OBJECT,
+                properties={
+                    "playlist_name": types.Schema(
+                        type=types.Type.STRING,
+                        description="The name for the new playlist",
+                    ),
+                    "songs": types.Schema(
+                        type=types.Type.ARRAY,
+                        description="A list of songs to add to the playlist",
+                        items=types.Schema(
+                            type=types.Type.OBJECT,
+                            properties={
+                                "title": types.Schema(type=types.Type.STRING),
+                                "artist": types.Schema(type=types.Type.STRING),
+                            },
+                            required=["title", "artist"],
+                        ),
+                    ),
+                },
+                required=["playlist_name", "songs"],
+            ),
+        ),
+        ChatCompletionToolParam(
+            type="function",
+            function={
+                "name": "create_playlist",
+                "description": "Creates a playlist from a list of songs.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "playlist_name": {
+                            "type": "string",
+                            "description": "The name for the new playlist",
+                        },
+                        "songs": {
+                            "type": "array",
+                            "description": "A list of songs to add to the playlist",
+                            "items": {
+                                "type": "object",
+                                "properties": {
+                                    "title": {"type": "string"},
+                                    "artist": {"type": "string"},
+                                },
+                                "required": ["title", "artist"],
+                            },
+                        },
+                    },
+                    "required": ["playlist_name", "songs"],
+                },
+            },
+        ),
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "_, function_declaration, expected_tool_param",
+    function_declaration_test_cases,
+    ids=[case[0] for case in function_declaration_test_cases],
+)
+async def test_function_declaration_to_tool_param(_, function_declaration, expected_tool_param):
+    """Test _convert_tools_to_openai function."""
+    tool = types.Tool(function_declarations=[function_declaration])
+    result = _convert_tools_to_openai([tool])
+    assert len(result) == 1
+    assert result[0] == expected_tool_param
+
+
+@pytest.mark.asyncio
+async def test_generate_content_async(openai_llm, llm_request, generate_content_response, generate_llm_response):
+    with mock.patch.object(openai_llm, "_client") as mock_client:
+        # Create a mock coroutine that returns the generate_content_response.
+        async def mock_coro(*args, **kwargs):
+            return generate_content_response
+
+        # Assign the coroutine to the mocked method
+        mock_client.chat.completions.create.return_value = mock_coro()
+
+        responses = [resp async for resp in openai_llm.generate_content_async(llm_request, stream=False)]
+        assert len(responses) == 1
+        assert isinstance(responses[0], LlmResponse)
+        assert responses[0].content is not None
+        assert len(responses[0].content.parts) > 0
+        assert responses[0].content.parts[0].text == "Hi! How can I help you today?"
+
+
+@pytest.mark.asyncio
+async def test_generate_content_async_with_max_tokens(llm_request, generate_content_response, generate_llm_response):
+    openai_llm = OpenAI(model="gpt-3.5-turbo", max_tokens=4096, type="openai")
+    with mock.patch.object(openai_llm, "_client") as mock_client:
+        # Create a mock coroutine that returns the generate_content_response.
+        async def mock_coro(*args, **kwargs):
+            return generate_content_response
+
+        # Assign the coroutine to the mocked method
+        mock_client.chat.completions.create.return_value = mock_coro()
+
+        _ = [resp async for resp in openai_llm.generate_content_async(llm_request, stream=False)]
+        mock_client.chat.completions.create.assert_called_once()
+        _, kwargs = mock_client.chat.completions.create.call_args
+        assert kwargs["max_tokens"] == 4096