smarta2a 0.4.26__py3-none-any.whl → 0.4.29__py3-none-any.whl

smarta2a/agent/a2a_human.py

@@ -37,7 +37,7 @@ class A2AHuman:
         
         @self.app.on_send_task(forward_to_webhook=True)
         async def on_send_task(request: SendTaskRequest, state: StateData):
-            return "I am human and will take some time to respond, please standby"
+            return "I am human and take some time to respond, but I will definitely respond to your request"
         
         @self.app.webhook()
         async def on_webhook(request: WebhookRequest, state: StateData):

smarta2a/model_providers/openai_provider.py

@@ -228,104 +228,11 @@ class OpenAIProvider(BaseLLMProvider):
         raise RuntimeError("Max tool iteration depth reached in generate().")
 
 
-    async def generate_stream(self, state: StateData, **kwargs) -> AsyncGenerator[str, None]:
+    async def stream(self, state: StateData, **kwargs) -> AsyncGenerator[str, None]:
         """
-        Stream response chunks, invoking tools as needed.
+        Stream a response, invoking tools as needed.
         """
-        context_history = state.context_history
-        # Normalize incoming messages to your Message model
-        msgs = [
-            msg if isinstance(msg, Message) else Message(**msg)
-            for msg in context_history
-        ]
-        # Convert to OpenAI schema, including any prior tool results
-        converted_messages = self._convert_messages(msgs)
-        max_iterations = 30
-
-        for _ in range(max_iterations):
-            # Kick off the streaming completion
-            stream = await self.client.chat.completions.create(
-                model=self.model,
-                messages=converted_messages,
-                tools=self._format_openai_tools(),
-                tool_choice="auto",
-                stream=True,
-                **kwargs
-            )
-
-            full_content = ""
-            tool_calls: List[Dict[str, Any]] = []
-
-            # As chunks arrive, yield them and collect any tool_call deltas
-            async for chunk in stream:
-                delta = chunk.choices[0].delta
-
-                # 1) Stream content immediately
-                if hasattr(delta, "content") and delta.content:
-                    yield delta.content
-                    full_content += delta.content
-
-                # 2) Buffer up any function/tool calls for after the stream
-                if hasattr(delta, "tool_calls") and delta.tool_calls:
-                    for d in delta.tool_calls:
-                        idx = d.index
-                        # Ensure list is long enough
-                        while len(tool_calls) <= idx:
-                            tool_calls.append({
-                                "id": "",
-                                "function": {"name": "", "arguments": ""}
-                            })
-                        if d.id:
-                            tool_calls[idx]["id"] = d.id
-                        if d.function.name:
-                            tool_calls[idx]["function"]["name"] = d.function.name
-                        if d.function.arguments:
-                            tool_calls[idx]["function"]["arguments"] += d.function.arguments
-
-            # If the assistant didn't invoke any tools, we're done
-            if not tool_calls:
-                return
-
-            # Otherwise, append the assistant's outgoing call and loop for tool execution
-            converted_messages.append({
-                "role": "assistant",
-                "content": full_content,
-                "tool_calls": [
-                    {
-                        "id": tc["id"],
-                        "type": "function",
-                        "function": {
-                            "name": tc["function"]["name"],
-                            "arguments": tc["function"]["arguments"]
-                        }
-                    }
-                    for tc in tool_calls
-                ]
-            })
-
-            # Execute each tool in turn and append its result
-            for tc in tool_calls:
-                name = tc["function"]["name"]
-                try:
-                    args = json.loads(tc["function"]["arguments"] or "{}")
-                except json.JSONDecodeError:
-                    args = {}
-                try:
-                    tool_res = await self.tools_manager.call_tool(name, args)
-                    result_content = getattr(tool_res, "content", None) or (
-                        tool_res.get("content") if isinstance(tool_res, dict) else str(tool_res)
-                    )
-                except Exception as e:
-                    result_content = f"Error executing {name}: {e}"
-
-                converted_messages.append({
-                    "role": "tool",
-                    "content": result_content,
-                    "tool_call_id": tc["id"]
-                })
-
-        raise RuntimeError("Max tool iteration depth reached in generate_stream().")
-
+        pass
 
 
     

smarta2a/server/request_handler.py

@@ -153,13 +153,6 @@ class RequestHandler:
                         push_notification_config=push_notification_config if push_notification_config else state_data.push_notification_config,
                     )
                 )
-
-            # If push_notification_config is set send the task to the push notification url
-            if push_notification_config and forward_to_webhook:
-                try:
-                    await self.a2a_aclient.send_to_webhook(webhook_url=push_notification_config.url,id=task_id,task=task.model_dump())
-                except Exception as e:
-                    pass
             
 
             # Send the task back to the client

smarta2a/server/server.py

@@ -108,7 +108,7 @@ class SmartA2A:
             # <-- Accept both SSE‐style responses:
             if isinstance(response, (EventSourceResponse, StreamingResponse)):
                 return response
-            
+            print(response)
             # <-- Everything else is a normal pydantic JSONRPCResponse
             return response.model_dump()
         
@@ -124,9 +124,6 @@ class SmartA2A:
         async def handle_webhook(request: Request):
             try:
                 data = await request.json()
-                print("--- In handle_webhook in server.py ---")
-                print(data)
-                print("--- end of handle_webhook in server.py ---")
                 req = WebhookRequest.model_validate(data)
             except Exception as e:
                 return WebhookResponse(accepted=False, error=str(e)).model_dump()

smarta2a/server/state_manager.py

@@ -7,7 +7,7 @@ from smarta2a.state_stores.base_state_store import BaseStateStore
 from smarta2a.file_stores.base_file_store import BaseFileStore
 from smarta2a.history_update_strategies.history_update_strategy import HistoryUpdateStrategy
 from smarta2a.utils.types import Message, StateData, Task, TaskStatus, TaskState, PushNotificationConfig, Part, FilePart
-from smarta2a.server.nats_client import NATSClient
+from smarta2a.client.nats_client import NATSClient
 
 class StateManager:
     def __init__(self, state_store: BaseStateStore, file_store: BaseFileStore, history_strategy: HistoryUpdateStrategy, nats_server_url: Optional[str] = "nats://localhost:4222", push_notification_config: Optional[PushNotificationConfig] = None):
@@ -112,7 +112,7 @@ class StateManager:
         for artifact in result.artifacts or []:
             if artifact.parts:
                 artifact_message = Message(
-                    role="agent",
+                    role="tool",
                     parts=artifact.parts,
                     metadata=artifact.metadata
                 )
@@ -132,7 +132,9 @@ class StateManager:
 
         # Merge artifacts
         if result.artifacts:
-            updated_state.task.artifacts = result.artifacts.copy()
+            if updated_state.task.artifacts is None:
+                updated_state.task.artifacts = []
+            updated_state.task.artifacts.extend(result.artifacts)
 
         # Merge metadata
         if result.metadata:

smarta2a/server/webhook_request_processor.py

@@ -1,145 +1,73 @@
 # Library imports
 from typing import Callable, Any, Optional
-import copy
-from uuid import uuid4
 
 # Local imports
 from smarta2a.server.state_manager import StateManager
-from smarta2a.utils.types import WebhookRequest, WebhookResponse, StateData, Message, TaskState
-from smarta2a.utils.task_builder import TaskBuilder
+from smarta2a.utils.types import WebhookRequest, WebhookResponse, StateData, Message
 from smarta2a.client.a2a_client import A2AClient
 
 class WebhookRequestProcessor:
     def __init__(self, webhook_fn: Callable[[WebhookRequest], Any], state_manager: Optional[StateManager] = None):
         self.webhook_fn = webhook_fn
         self.state_manager = state_manager
-        self.task_builder = TaskBuilder(default_status=TaskState.COMPLETED)
         self.a2a_aclient = A2AClient()
 
     async def process_request(self, request: WebhookRequest) -> WebhookResponse:
         if self.state_manager:
-            state_data = await self.state_manager.get_and_update_state_from_webhook(request.id, request.result)
+            state_data = self.state_manager.get_and_update_state_from_webhook(request.id, request.result)
             return await self._webhook_handler(request, state_data)
         else:
             return await self._webhook_handler(request)
-    
+
 
     async def _webhook_handler(self, request: WebhookRequest, state_data: Optional[StateData] = None) -> WebhookResponse:
-        print("--- _webhook_handler ---")
-        print(request)
-        print("--- end of _webhook_handler ---")
-        print("--- state_data ---")
-        print(state_data)
-        print("--- end of state_data ---")
         try:
-            # Extract parameters from request
-            task_id = request.id
-            task = request.result
+            # --- Step 1: Process Incoming Task ---
+            if request.result:
+                incoming_task = request.result
+                
+                # Initialize state_data if missing
+                if not state_data:
+                    state_data = StateData(
+                        task_id=incoming_task.id,
+                        task=incoming_task.copy(update={"artifacts": incoming_task.artifacts}),
+                        context_history=[],
+                        push_notification_config=None
+                    )
 
-            if state_data:
-                session_id = task.sessionId if task and task.sessionId else state_data.task.sessionId
-                task_history = task.history if task and task.history is not None else state_data.task.history.copy() if state_data.task.history else []
-                context_history = state_data.context_history.copy()
-                metadata = task.metadata if task and task.metadata is not None else state_data.task.metadata.copy() if state_data.task.metadata else {}
-                # Deep copy of push_notification_config
-                push_notification_config = copy.deepcopy(state_data.push_notification_config) if state_data.push_notification_config else None
-            else:
-                # No state_data so just assign based on task from the request
-                session_id = task.sessionId if task and task.sessionId else str(uuid4())
-                task_history = task.history if task and task.history else []
-                context_history = []
-                metadata = task.metadata if task and task.metadata else {}
-                push_notification_config = None
-            
-            # Call webhook handler
-            if state_data:
-                # Call webhook_fn with state_data
-                raw_result = await self.webhook_fn(request, state_data)
-            else:
-                # Call webhook_fn with request
-                raw_result = await self.webhook_fn(request)
-            
-            print("--- raw_result ---")
-            print(raw_result)
-            print("--- end of raw_result ---")
-            
-            # Handle direct WebhookResponse returns
-            if isinstance(raw_result, WebhookResponse):
-                return raw_result
-            
-            # Process webhook_response in a way that is similar to handle_send_task
-            # Build task with updated history
-            updated_task = self.task_builder.build(
-                content=raw_result,
-                task_id=task_id,
-                session_id=session_id,
-                metadata=metadata,
-                history=task_history
-            )
-            
-            # Process messages through strategy (similar to handle_send_task)
-            messages = []
-            if updated_task.artifacts:
-                agent_parts = [p for a in updated_task.artifacts for p in a.parts]
-                agent_message = Message(
-                    role="agent",
-                    parts=agent_parts,
-                    metadata=updated_task.metadata
-                )
-                messages.append(agent_message)
+            # --- Step 2: Call Webhook Function ---
+            webhook_response = await self.webhook_fn(request, state_data) if state_data else await self.webhook_fn(request)
             
-            # Update Task history with a simple append
-            task_history.extend(messages)
-            
-            if state_data:
-                # Update context history with a strategy
-                history_strategy = self.state_manager.get_history_strategy()
-                context_history = history_strategy.update_history(
-                    existing_history=context_history,
-                    new_messages=messages
-                )
-            
-            print("--- task_history ---")
-            print(task_history)
-            print("--- end of task_history ---")
-            print("--- context_history ---")
-            print(context_history)
-            print("--- end of context_history ---")
-            # Update task with final state
-            updated_task.history = task_history
-            
-            # State store update (if enabled)
-            if state_data:
-                await self.state_manager.update_state(
-                    state_data=StateData(
-                        task_id=task_id,
-                        task=updated_task,
-                        context_history=context_history,
-                        push_notification_config=push_notification_config,
+            # --- Step 3: Process Webhook Response ---
+            if webhook_response.result:
+                updated_task = webhook_response.result
+                existing_task = state_data.task
+                
+                # Overwrite artifacts from response
+                existing_task.artifacts = updated_task.artifacts.copy() if updated_task.artifacts else []
+                
+                # Merge metadata
+                existing_task.metadata = {**(existing_task.metadata or {}), **(updated_task.metadata or {})}
+                
+                # Build messages from updated artifacts
+                updated_parts = [part for artifact in updated_task.artifacts for part in artifact.parts] if updated_task.artifacts else []
+                updated_messages = [Message(role="agent", parts=updated_parts, metadata=updated_task.metadata)]
+                
+                # Update context history again
+                if self.state_manager:
+                    history_strategy = self.state_manager.get_history_strategy()
+                    state_data.context_history = history_strategy.update_history(
+                        existing_history=state_data.context_history,
+                        new_messages=updated_messages
                     )
-                )
-            print("--- push_notification_config ---")
-            print(push_notification_config)
-            print("--- end of push_notification_config ---")
-            # If push_notification_config is set send the task to the push notification url
-            if push_notification_config:
-                try:
-                    await self.a2a_aclient.send_to_webhook(webhook_url=push_notification_config.url,id=task_id,task=updated_task.model_dump())
-                except Exception as e:
-                    pass
+                    await self.state_manager.update_state(state_data)
             
-            # Return the updated task
+
+            # --- Step 5: Return Final Response ---
             return WebhookResponse(
                 id=request.id,
-                result=updated_task
+                result=state_data.task if state_data else None
             )
-            
+        
         except Exception as e:
-            print("--- EXCEPTION CAUGHT ---")
-            print(e)
-            print("--- END OF EXCEPTION CAUGHT ---")
-            # Handle exceptions
-            return WebhookResponse(
-                id=request.id,
-                error=str(e)
-            )
+            return WebhookResponse(id=request.id, error=f"Internal error: {str(e)}")

{smarta2a-0.4.26.dist-info → smarta2a-0.4.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smarta2a
-Version: 0.4.26
+Version: 0.4.29
 Summary: a Python framework that helps you build servers and AI agents that communicate using the A2A protocol
 Project-URL: Homepage, https://github.com/siddharthsma/smarta2a
 Project-URL: Bug Tracker, https://github.com/siddharthsma/smarta2a/issues
@@ -64,7 +64,7 @@ SmartA2A makes it easy to build interoperable, communication-ready AI systems—
 ## Installation
 
 ```bash
-pip install -U smarta2a
+pip install -U smarta2a==0.3.1
 ```
 
 ## Examples
@@ -389,16 +389,6 @@ This example demonstrates:
 
 ---
 
-## Roadmap
-
-There's still a lot more to come ...
-
-- Documentation site with tutorials, explanation of concepts, blog and a contribution guide
-- Support for more LLM providers
-- Support for more memory types
-- Authorization and observability framework built-in
-- Many more !
-
 ## License
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details. 

{smarta2a-0.4.26.dist-info → smarta2a-0.4.29.dist-info}/RECORD

@@ -1,6 +1,6 @@
 smarta2a/__init__.py,sha256=T_EECYqWrxshix0FbgUv22zlKRX22HFU-HKXcYTOb3w,175
 smarta2a/agent/a2a_agent.py,sha256=EurcxpV14e3OPWCMutYL0EXMHb5ZKQqAHEGZZF6pNgg,1892
-smarta2a/agent/a2a_human.py,sha256=Bz4M9rhEwQEtIdDnV7VTL2n14nTT2wACyPBhDMph4FQ,1645
+smarta2a/agent/a2a_human.py,sha256=yAW9naxyqStQhWwDamXRZIlw-mT_7RW2wcHyhy3rR6Y,1671
 smarta2a/agent/a2a_mcp_server.py,sha256=X_mxkgYgCA_dSNtCvs0rSlOoWYc-8d3Qyxv0e-a7NKY,1015
 smarta2a/archive/smart_mcp_client.py,sha256=0s2OWFKWSv-_UF7rb9fOrsh1OIYsYOsGukkXXp_E1cU,4158
 smarta2a/archive/subscription_service.py,sha256=vftmZD94HbdjPFa_1UBvsBm-WkW-s3ZCVq60fF7OCgA,4109
@@ -8,6 +8,7 @@ smarta2a/archive/task_service.py,sha256=ptf-oMHy98Rw4XSxyK1-lpqc1JtkCkEEHTmwAaun
 smarta2a/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 smarta2a/client/a2a_client.py,sha256=apDkKFtq61T79LpkbkzVTKWA0mSjR_eTNdGPUYozyvk,12100
 smarta2a/client/mcp_client.py,sha256=JeXhBqxM9TYAArpExLRtEr3lZeQZMcnTmGFl6XKsdu8,3797
+smarta2a/client/nats_client.py,sha256=K97e8awvAxsqgs3BxsTZU_mB3JPPZ0yjLX1LnZZjfXE,1450
 smarta2a/file_stores/base_file_store.py,sha256=fcwFIOoFjLQiIKb8lIRVujnV6udyuI9Dq8cEc2ldmIQ,591
 smarta2a/file_stores/local_file_store.py,sha256=4GLDrsKxSoLWn2Oha4OD-P2r5vBpfV-8ePvZ5bhP1e8,2616
 smarta2a/history_update_strategies/__init__.py,sha256=x5WtiE9rG5ze8d8hA6E6wJOciBhWHa_ZgGgoIAZcXEQ,213
@@ -16,16 +17,14 @@ smarta2a/history_update_strategies/history_update_strategy.py,sha256=n2sfIGu8ztK
 smarta2a/history_update_strategies/rolling_window_strategy.py,sha256=7Ch042JWt4TM_r1-sFKlSIxHj8VX1P3ZoqjCvIdeSqA,540
 smarta2a/model_providers/__init__.py,sha256=hJj0w00JjqTiBgJmHmOWwL6MU_hwmro9xTiX3XYf6ts,148
 smarta2a/model_providers/base_llm_provider.py,sha256=iQUqjnypl0f2M929iU0WhHoxAE4ek-NUFJPbEnNQ8-4,412
-smarta2a/model_providers/openai_provider.py,sha256=cqAAhoImHJtBVOGeIERphXqiNlq6MSe_p3-3gImhAeM,12221
+smarta2a/model_providers/openai_provider.py,sha256=iL4qgRhQQs1hFT2KblAYoS-4UUQL8z2z5YLGzfaRDfw,8348
 smarta2a/server/__init__.py,sha256=f2X454Ll4vJc02V4JLJHTN-h8u0TBm4d_FkiO4t686U,53
 smarta2a/server/handler_registry.py,sha256=OVRG5dTvxB7qUNXgsqWxVNxIyRljUShSYxb1gtbi5XM,820
 smarta2a/server/json_rpc_request_processor.py,sha256=qRB3sfj_n9ImkIOCdaUKMsDmKcO7CiMhaZ4VdQS7Mb4,6993
-smarta2a/server/nats_client.py,sha256=K97e8awvAxsqgs3BxsTZU_mB3JPPZ0yjLX1LnZZjfXE,1450
-smarta2a/server/request_handler.py,sha256=tUAoxkrJtOnLPJxdUDMThGPFAxYnNFFofS3QD80g_8M,26184
-smarta2a/server/send_task_handler.py,sha256=fiBeCCHCu9c2H4EJOUc0t3EZgpHVFJy4B_6qZOC140s,6336
-smarta2a/server/server.py,sha256=L0vh1i-s8bAQKarTPkqzZRdZuqFUjoqeGOCfo8wUvgU,6782
-smarta2a/server/state_manager.py,sha256=SKXK02g0o5-r3lYOJdCQaciYUnFTMGtB5MFdfgTc_ug,7962
-smarta2a/server/webhook_request_processor.py,sha256=EVIU6J6gd5eCl-QJER-dDxd8dSczFfXN7o_qA-fD5sc,6387
+smarta2a/server/request_handler.py,sha256=zw3nRHZCX0xBx0x0sK5t8GjJRwOtUil-uVYhD3J0R7E,25807
+smarta2a/server/server.py,sha256=0qpIQ1KXTUtFygcl-2SPIVTRVooobW_EmdXq83wvAPw,6637
+smarta2a/server/state_manager.py,sha256=fdMOypRpaHaaexlMo0lk_MQX_FGYNzOLqVB0a4efiug,8063
+smarta2a/server/webhook_request_processor.py,sha256=XQUsfOhXwDiKOdpRa7BmN2C5tgBbgtXATgzA4sM38dU,3431
 smarta2a/state_stores/__init__.py,sha256=vafxAqpwvag_cYFH2XKGk3DPmJIWJr4Ioey30yLFkVQ,220
 smarta2a/state_stores/base_state_store.py,sha256=_3LInM-qepKwwdypJTDNs9-DozBNrKVycwPwUm7bYdU,512
 smarta2a/state_stores/inmemory_state_store.py,sha256=nEBBUiiqhEluP2MYJjFUImcjIwLJEvL8BWwMbLCb8Fw,1268
@@ -36,7 +35,7 @@ smarta2a/utils/task_builder.py,sha256=wqSyfVHNTaXuGESu09dhlaDi7D007gcN3-8tH-nPQ4
 smarta2a/utils/task_request_builder.py,sha256=6cOGOqj2Rg43xWM03GRJQzlIZHBptsMCJRp7oD-TDAQ,3362
 smarta2a/utils/tools_manager.py,sha256=oR5cbwzPZ36hQAsWAgb-c6wFv5BthmCPraD7DSv-Bv8,4332
 smarta2a/utils/types.py,sha256=kzA6Vv5xXfu1sJuxhEXrglI9e9S6eZVIljMnsrQVyN0,13650
-smarta2a-0.4.26.dist-info/METADATA,sha256=iZsYh0J38iorZ7XeHEMJuStHsHbYRrAT5ujtdoSjcf0,13051
-smarta2a-0.4.26.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-smarta2a-0.4.26.dist-info/licenses/LICENSE,sha256=lDbqrxVnzDMY5KJ8JS1WhvkWE8TJaw-O-CHDy-ecsJA,2095
-smarta2a-0.4.26.dist-info/RECORD,,
+smarta2a-0.4.29.dist-info/METADATA,sha256=dTQkVsjbmETIm4CE45NwU0TtdD7-9UCh7QX3UPDb7RI,12783
+smarta2a-0.4.29.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+smarta2a-0.4.29.dist-info/licenses/LICENSE,sha256=lDbqrxVnzDMY5KJ8JS1WhvkWE8TJaw-O-CHDy-ecsJA,2095
+smarta2a-0.4.29.dist-info/RECORD,,

smarta2a/server/send_task_handler.py

@@ -1,174 +0,0 @@
-# Library imports
-from typing import Optional
-from uuid import uuid4
-import json
-from pydantic import ValidationError
-
-# Local imports
-from smarta2a.utils.types import (
-    JSONRPCRequest,
-    SendTaskRequest,
-    SendTaskResponse,
-    StateData,
-    Task,
-    TaskStatus,
-    TaskState,
-    Message,
-    JSONRPCError,
-    InvalidRequestError,
-    JSONParseError,
-    InternalError,
-    MethodNotFoundError
-)
-
-class SendTaskHandler:
-
-    @classmethod
-    async def _handle_send_task(self, request_data: JSONRPCRequest, state_data: Optional[StateData] = None) -> SendTaskResponse:
-        try:
-            # Validate request format
-            request = SendTaskRequest.model_validate(request_data.model_dump())
-            handler = self.registry.get_handler("tasks/send")
-            
-            if not handler:
-                return SendTaskResponse(
-                    id=request.id,
-                    error=MethodNotFoundError()
-                )
-            
-            # Extract parameters from request
-            task_id = request.params.id
-            session_id = request.params.sessionId or str(uuid4())
-            raw = request.params.message
-            user_message = Message.model_validate(raw)
-            request_metadata = request.params.metadata or {}
-            
-            if state_data:
-                task_history = state_data.task.history.copy() or []
-                context_history = state_data.context_history.copy() or []
-                metadata = state_data.task.metadata or {}
-
-                # Call handler with state data
-                raw_result = await handler(request, state_data)
-
-                # Handle direct SendTaskResponse returns
-                if isinstance(raw_result, SendTaskResponse):
-                    return raw_result
-
-                # Build task with updated history (before agent response)
-                task = self.task_builder.build(
-                    content=raw_result,
-                    task_id=task_id,
-                    session_id=session_id,  
-                    metadata=metadata,  
-                    history=task_history 
-                )
-
-                # Process messages through strategy
-                messages = []
-                if task.artifacts:
-                    agent_parts = [p for a in task.artifacts for p in a.parts]
-                    agent_message = Message(
-                        role="agent",
-                        parts=agent_parts,
-                        metadata=task.metadata
-                    )
-                    messages.append(agent_message)
-
-                # Update Task history with a simple append
-                task_history.extend(messages)
-
-                # Update context history with a strategy - this is the history that will be passed to an LLM call
-                history_strategy = self.state_mgr.get_history_strategy()
-                context_history = history_strategy.update_history(
-                    existing_history=context_history,
-                    new_messages=messages
-                )
-
-                # Update task with final state
-                task.history = task_history
-
-                # State store update (if enabled)
-                if self.state_mgr:
-                    state_store = self.state_mgr.get_store()
-                    state_store.update_state(
-                        task_id=task_id,
-                        state_data=StateData(
-                            task_id=task_id,
-                            task=task,
-                            context_history=context_history,
-                            metadata=metadata  # Use merged metadata
-                        )
-                    )
-                
-            else:
-                # There is no state manager, so we need to build a task from scratch
-                task = Task(
-                    id=task_id,
-                    sessionId=session_id,
-                    status=TaskStatus(state=TaskState.WORKING),
-                    history=[user_message],
-                    metadata=request_metadata
-                )
-                task_history = task.history.copy() 
-                metadata = request_metadata.copy()
-
-                # Call handler without state data
-                raw_result = await handler(request)
-
-                # Handle direct SendTaskResponse returns
-                if isinstance(raw_result, SendTaskResponse):
-                    return raw_result
-                
-                # Build task with updated history (before agent response)
-                task = self.task_builder.build(
-                    content=raw_result,
-                    task_id=task_id,
-                    session_id=session_id,  
-                    metadata=metadata,  
-                    history=task_history 
-                )
-
-                # Process messages through strategy
-                messages = []
-                if task.artifacts:
-                    agent_parts = [p for a in task.artifacts for p in a.parts]
-                    agent_message = Message(
-                        role="agent",
-                        parts=agent_parts,
-                        metadata=task.metadata
-                    )
-                    messages.append(agent_message)
-
-                # Update Task history with a simple append
-                task_history.extend(messages)
-
-                # Update task with final state
-                task.history = task_history
-
-
-            return SendTaskResponse(
-                    id=request.id,
-                    result=task
-                )
-        except ValidationError as e:
-            return SendTaskResponse(
-                id=request_data.id,
-                error=InvalidRequestError(data=e.errors())
-            )
-        except json.JSONDecodeError as e:
-            return SendTaskResponse(
-                id=request_data.id,
-                error=JSONParseError(data=str(e))
-            )
-        except Exception as e:
-            # Handle case where handler returns SendTaskResponse with error
-            if isinstance(e, JSONRPCError):
-                return SendTaskResponse(
-                    id=request.id,
-                    error=e
-                )
-            return SendTaskResponse(
-                id=request.id,
-                error=InternalError(data=str(e))
-            )