kagent-adk 0.6.11__tar.gz → 0.6.14__tar.gz

{kagent_adk-0.6.11 → kagent_adk-0.6.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kagent-adk
-Version: 0.6.11
+Version: 0.6.14
 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.11 → kagent_adk-0.6.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "kagent-adk"
-version = "0.6.11"
+version = "0.6.14"
 description = "kagent-adk is an sdk for integrating adk agents with kagent"
 readme = "README.md"
 requires-python = ">=3.12.11"

{kagent_adk-0.6.11 → kagent_adk-0.6.14}/src/kagent/adk/_session_service.py

@@ -24,10 +24,6 @@ class KAgentSessionService(BaseSessionService):
         super().__init__()
         self.client = client
 
-    async def _get_user_id(self) -> str:
-        """Get the default user ID. Override this method to implement custom user ID logic."""
-        return "admin@kagent.dev"
-
     @override
     async def create_session(
         self,

{kagent_adk-0.6.11 → kagent_adk-0.6.14}/src/kagent/adk/models/_openai.py

@@ -9,6 +9,7 @@ from typing import TYPE_CHECKING, Any, AsyncGenerator, Iterable, Literal, Option
 from google.adk.models import BaseLlm
 from google.adk.models.llm_response import LlmResponse
 from google.genai import types
+from google.genai.types import FunctionCall, FunctionResponse
 from openai import AsyncAzureOpenAI, AsyncOpenAI
 from openai.types.chat import (
     ChatCompletion,
@@ -27,7 +28,7 @@ from openai.types.chat.chat_completion_message_tool_call_param import (
 from openai.types.chat.chat_completion_message_tool_call_param import (
     Function as ToolCallFunction,
 )
-from openai.types.shared_params import FunctionDefinition
+from openai.types.shared_params import FunctionDefinition, FunctionParameters
 from pydantic import Field
 
 if TYPE_CHECKING:
@@ -56,7 +57,7 @@ def _convert_content_to_openai_messages(
         messages.append(system_message)
 
     # First pass: collect all function responses to match with tool calls
-    all_function_responses = {}
+    all_function_responses: dict[str, FunctionResponse] = {}
     for content in contents:
         for part in content.parts or []:
             if part.function_response:
@@ -67,18 +68,18 @@ def _convert_content_to_openai_messages(
         role = _convert_role_to_openai(content.role)
 
         # Separate different types of parts
-        text_parts = []
-        function_calls = []
-        function_responses = []
+        text_parts: list[str] = []
+        function_calls: list[FunctionCall] = []
+        function_responses: list[FunctionResponse] = []
         image_parts = []
 
         for part in content.parts or []:
             if part.text:
                 text_parts.append(part.text)
             elif part.function_call:
-                function_calls.append(part)
+                function_calls.append(part.function_call)
             elif part.function_response:
-                function_responses.append(part)
+                function_responses.append(part.function_response)
             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()
@@ -98,43 +99,43 @@ def _convert_content_to_openai_messages(
 
             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,
+                    "name": func_call.name or "",
+                    "arguments": json.dumps(func_call.args) if func_call.args else "{}",
                 }
+                tool_call_id = func_call.id or "call_1"
+                tool_call = ChatCompletionMessageToolCallParam(
+                    id=tool_call_id,
+                    type="function",
+                    function=tool_call_function,
+                )
                 tool_calls.append(tool_call)
 
                 # Check if we have a response for this tool call
                 if tool_call_id in all_function_responses:
                     func_response = all_function_responses[tool_call_id]
-                    tool_message: ChatCompletionToolMessageParam = {
-                        "role": "tool",
-                        "tool_call_id": tool_call_id,
-                        "content": str(func_response.response.get("result", "")) if func_response.response else "",
-                    }
+                    tool_message = ChatCompletionToolMessageParam(
+                        role="tool",
+                        tool_call_id=tool_call_id,
+                        content=str(func_response.response.get("result", "")) if func_response.response else "",
+                    )
                     tool_response_messages.append(tool_message)
                 else:
                     # If no response is available, create a placeholder response
                     # This prevents the OpenAI API error
-                    tool_message: ChatCompletionToolMessageParam = {
-                        "role": "tool",
-                        "tool_call_id": tool_call_id,
-                        "content": "No response available for this function call.",
-                    }
+                    tool_message = ChatCompletionToolMessageParam(
+                        role="tool",
+                        tool_call_id=tool_call_id,
+                        content="No response available for this function call.",
+                    )
                     tool_response_messages.append(tool_message)
 
             # 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,
-            }
+            assistant_message = ChatCompletionAssistantMessageParam(
+                role="assistant",
+                content=text_content,
+                tool_calls=tool_calls,
+            )
             messages.append(assistant_message)
 
             # Add all tool response messages immediately after the assistant message
@@ -145,22 +146,22 @@ def _convert_content_to_openai_messages(
             if role == "user":
                 if image_parts and text_parts:
                     # Multi-modal content
-                    text_part: ChatCompletionContentPartTextParam = {"type": "text", "text": "\n".join(text_parts)}
+                    text_part = ChatCompletionContentPartTextParam(type="text", text="\n".join(text_parts))
                     content_parts = [text_part] + image_parts
-                    user_message: ChatCompletionUserMessageParam = {"role": "user", "content": content_parts}
+                    user_message = ChatCompletionUserMessageParam(role="user", content=content_parts)
                 elif image_parts:
                     # Image only
-                    user_message: ChatCompletionUserMessageParam = {"role": "user", "content": image_parts}
+                    user_message = ChatCompletionUserMessageParam(role="user", content=image_parts)
                 else:
                     # Text only
-                    user_message: ChatCompletionUserMessageParam = {"role": "user", "content": "\n".join(text_parts)}
+                    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),
-                }
+                assistant_message = ChatCompletionAssistantMessageParam(
+                    role="assistant",
+                    content="\n".join(text_parts),
+                )
                 messages.append(assistant_message)
 
     return messages
@@ -197,10 +198,10 @@ def _convert_tools_to_openai(tools: list[types.Tool]) -> list[ChatCompletionTool
         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 "",
-                }
+                function_def = FunctionDefinition(
+                    name=func_decl.name or "",
+                    description=func_decl.description or "",
+                )
 
                 # Always include parameters field, even if empty
                 properties = {}
@@ -219,7 +220,7 @@ def _convert_tools_to_openai(tools: list[types.Tool]) -> list[ChatCompletionTool
                 function_def["parameters"] = {"type": "object", "properties": properties, "required": required}
 
                 # Create the tool param
-                openai_tool: ChatCompletionToolParam = {"type": "function", "function": function_def}
+                openai_tool = ChatCompletionToolParam(type="function", function=function_def)
                 openai_tools.append(openai_tool)
 
     return openai_tools
@@ -389,6 +390,7 @@ class AzureOpenAI(BaseOpenAI):
     api_version: Optional[str] = None
     azure_endpoint: Optional[str] = None
     azure_deployment: Optional[str] = None
+    headers: Optional[dict[str, str]] = None
 
     @cached_property
     def _client(self) -> AsyncAzureOpenAI:
@@ -407,4 +409,8 @@ class AzureOpenAI(BaseOpenAI):
                 "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)
+        default_headers = self.headers or {}
+
+        return AsyncAzureOpenAI(
+            api_version=api_version, azure_endpoint=azure_endpoint, api_key=api_key, default_headers=default_headers
+        )

{kagent_adk-0.6.11 → kagent_adk-0.6.14}/src/kagent/adk/types.py

@@ -1,10 +1,12 @@
+import httpx
 import logging
-from typing import Literal, Self, Union
+
+from typing import Literal, Any, Union
 
 from google.adk.agents import Agent
 from google.adk.agents.base_agent import BaseAgent
 from google.adk.agents.llm_agent import ToolUnion
-from google.adk.agents.remote_a2a_agent import AGENT_CARD_WELL_KNOWN_PATH, RemoteA2aAgent
+from google.adk.agents.remote_a2a_agent import AGENT_CARD_WELL_KNOWN_PATH, DEFAULT_TIMEOUT, RemoteA2aAgent
 from google.adk.models.anthropic_llm import Claude as ClaudeLLM
 from google.adk.models.google_llm import Gemini as GeminiLLM
 from google.adk.models.lite_llm import LiteLlm
@@ -31,11 +33,14 @@ class SseMcpServerConfig(BaseModel):
 class RemoteAgentConfig(BaseModel):
     name: str
     url: str
+    headers: dict[str, Any] | None = None
+    timeout: float = DEFAULT_TIMEOUT
     description: str = ""
 
 
 class BaseLLM(BaseModel):
     model: str
+    headers: dict[str, str] | None = None
 
 
 class OpenAI(BaseLLM):
@@ -76,41 +81,56 @@ class AgentConfig(BaseModel):
     )
     description: str
     instruction: str
-    http_tools: list[HttpMcpServerConfig] | None = None  # tools, always MCP
-    sse_tools: list[SseMcpServerConfig] | None = None  # tools, always MCP
+    http_tools: list[HttpMcpServerConfig] | None = None  # Streamable HTTP MCP tools
+    sse_tools: list[SseMcpServerConfig] | None = None  # SSE MCP tools
     remote_agents: list[RemoteAgentConfig] | None = None  # remote agents
 
     def to_agent(self, name: str) -> Agent:
         if name is None or not str(name).strip():
             raise ValueError("Agent name must be a non-empty string.")
-        mcp_toolsets: list[ToolUnion] = []
+        tools: list[ToolUnion] = []
         if self.http_tools:
             for http_tool in self.http_tools:  # add http tools
-                mcp_toolsets.append(MCPToolset(connection_params=http_tool.params, tool_filter=http_tool.tools))
+                tools.append(MCPToolset(connection_params=http_tool.params, tool_filter=http_tool.tools))
         if self.sse_tools:
             for sse_tool in self.sse_tools:  # add stdio tools
-                mcp_toolsets.append(MCPToolset(connection_params=sse_tool.params, tool_filter=sse_tool.tools))
+                tools.append(MCPToolset(connection_params=sse_tool.params, tool_filter=sse_tool.tools))
         if self.remote_agents:
             for remote_agent in self.remote_agents:  # Add remote agents as tools
-                remote_agent = RemoteA2aAgent(
+                client = None
+
+                if remote_agent.headers:
+                    client = httpx.AsyncClient(
+                        headers=remote_agent.headers, timeout=httpx.Timeout(timeout=remote_agent.timeout)
+                    )
+
+                remote_a2a_agent = RemoteA2aAgent(
                     name=remote_agent.name,
                     agent_card=f"{remote_agent.url}/{AGENT_CARD_WELL_KNOWN_PATH}",
                     description=remote_agent.description,
+                    httpx_client=client,
                 )
-                mcp_toolsets.append(AgentTool(agent=remote_agent, skip_summarization=True))
+
+                tools.append(
+                    AgentTool(agent=remote_a2a_agent, skip_summarization=True)
+                )  # Get headers from model config
+
+        extra_headers = self.model.headers or {}
 
         if self.model.type == "openai":
             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)
+            model = LiteLlm(
+                model=f"anthropic/{self.model.model}", base_url=self.model.base_url, extra_headers=extra_headers
+            )
         elif self.model.type == "gemini_vertex_ai":
             model = GeminiLLM(model=self.model.model)
         elif self.model.type == "gemini_anthropic":
             model = ClaudeLLM(model=self.model.model)
         elif self.model.type == "ollama":
-            model = LiteLlm(model=f"ollama_chat/{self.model.model}")
+            model = LiteLlm(model=f"ollama_chat/{self.model.model}", extra_headers=extra_headers)
         elif self.model.type == "azure_openai":
-            model = OpenAIAzure(model=self.model.model, type="azure_openai")
+            model = OpenAIAzure(model=self.model.model, type="azure_openai", headers=extra_headers)
         elif self.model.type == "gemini":
             model = self.model.model
         else:
@@ -120,5 +140,5 @@ class AgentConfig(BaseModel):
             model=model,
             description=self.description,
             instruction=self.instruction,
-            tools=mcp_toolsets,
+            tools=tools,
         )

kagent_adk-0.6.14/tests/unittests/converters/test_event_converter.py

@@ -0,0 +1,119 @@
+from unittest.mock import Mock
+
+import pytest
+from a2a.types import TaskState, TaskStatusUpdateEvent
+from google.genai import types as genai_types
+
+from kagent.adk.converters.event_converter import convert_event_to_a2a_events
+from kagent.core.a2a import get_kagent_metadata_key
+
+
+def _create_mock_invocation_context():
+    """Create a mock invocation context for testing."""
+    context = Mock()
+    context.app_name = "test_app"
+    context.user_id = "test_user"
+    context.session.id = "test_session"
+    return context
+
+
+def _create_mock_event(error_code=None, content=None, invocation_id="test_invocation", author="test_author"):
+    """Create a mock event for testing."""
+    event = Mock()
+    event.error_code = error_code
+    event.content = content
+    event.invocation_id = invocation_id
+    event.author = author
+    event.branch = None
+    event.grounding_metadata = None
+    event.custom_metadata = None
+    event.usage_metadata = None
+    event.error_message = None
+    return event
+
+
+class TestEventConverter:
+    """Test cases for event converter functions."""
+
+    def test_convert_event_to_a2a_events(self):
+        """Test that STOP error codes with empty content don't create any events, while actual error codes create error events."""
+
+        invocation_context = _create_mock_invocation_context()
+
+        # Test case 1: Empty content with STOP error code
+        event1 = _create_mock_event(
+            error_code=genai_types.FinishReason.STOP, content=None, invocation_id="test_invocation_1"
+        )
+        result1 = convert_event_to_a2a_events(
+            event1, invocation_context, task_id="test_task_1", context_id="test_context_1"
+        )
+        error_events1 = [
+            e for e in result1 if isinstance(e, TaskStatusUpdateEvent) and e.status.state == TaskState.failed
+        ]
+        working_events1 = [
+            e for e in result1 if isinstance(e, TaskStatusUpdateEvent) and e.status.state == TaskState.working
+        ]
+        assert len(error_events1) == 0, (
+            f"Expected no error events for STOP with empty content, got {len(error_events1)}"
+        )
+        assert len(working_events1) == 0, (
+            f"Expected no working events for STOP with empty content (no content to convert), got {len(working_events1)}"
+        )
+
+        # Test case 2: Empty parts with STOP error code
+        content_mock = Mock()
+        content_mock.parts = []
+        event2 = _create_mock_event(
+            error_code=genai_types.FinishReason.STOP, content=content_mock, invocation_id="test_invocation_2"
+        )
+        result2 = convert_event_to_a2a_events(
+            event2, invocation_context, task_id="test_task_2", context_id="test_context_2"
+        )
+        error_events2 = [
+            e for e in result2 if isinstance(e, TaskStatusUpdateEvent) and e.status.state == TaskState.failed
+        ]
+        working_events2 = [
+            e for e in result2 if isinstance(e, TaskStatusUpdateEvent) and e.status.state == TaskState.working
+        ]
+        assert len(error_events2) == 0, f"Expected no error events for STOP with empty parts, got {len(error_events2)}"
+        assert len(working_events2) == 0, (
+            f"Expected no working events for STOP with empty parts (no content to convert), got {len(working_events2)}"
+        )
+
+        # Test case 3: Missing content with STOP error code
+        event3 = _create_mock_event(
+            error_code=genai_types.FinishReason.STOP, content=None, invocation_id="test_invocation_3"
+        )
+        result3 = convert_event_to_a2a_events(
+            event3, invocation_context, task_id="test_task_3", context_id="test_context_3"
+        )
+        error_events3 = [
+            e for e in result3 if isinstance(e, TaskStatusUpdateEvent) and e.status.state == TaskState.failed
+        ]
+        working_events3 = [
+            e for e in result3 if isinstance(e, TaskStatusUpdateEvent) and e.status.state == TaskState.working
+        ]
+        assert len(error_events3) == 0, (
+            f"Expected no error events for STOP with missing content, got {len(error_events3)}"
+        )
+        assert len(working_events3) == 0, (
+            f"Expected no working events for STOP with missing content (no content to convert), got {len(working_events3)}"
+        )
+
+        # Test case 4: Actual error code should create error event
+        event4 = _create_mock_event(
+            error_code=genai_types.FinishReason.MALFORMED_FUNCTION_CALL, content=None, invocation_id="test_invocation_4"
+        )
+        result4 = convert_event_to_a2a_events(
+            event4, invocation_context, task_id="test_task_4", context_id="test_context_4"
+        )
+        error_events4 = [
+            e for e in result4 if isinstance(e, TaskStatusUpdateEvent) and e.status.state == TaskState.failed
+        ]
+        assert len(error_events4) == 1, f"Expected 1 error event for MALFORMED_FUNCTION_CALL, got {len(error_events4)}"
+
+        # Check that the error event has the correct error code in metadata
+        error_event = error_events4[0]
+        error_code_key = get_kagent_metadata_key("error_code")
+        assert error_code_key in error_event.metadata
+        assert error_event.metadata[error_code_key] == str(genai_types.FinishReason.MALFORMED_FUNCTION_CALL)