smarta2a 0.3.1__py3-none-any.whl → 0.4.1__py3-none-any.whl

smarta2a/agent/a2a_agent.py

@@ -1,30 +1,29 @@
 # Library imports
-
+from fastapi import Query
+from fastapi.responses import JSONResponse
+from typing import Optional
 
 # Local imports
 from smarta2a.server import SmartA2A
 from smarta2a.model_providers.base_llm_provider import BaseLLMProvider
-from smarta2a.history_update_strategies.history_update_strategy import HistoryUpdateStrategy
-from smarta2a.history_update_strategies.append_strategy import AppendStrategy
-from smarta2a.state_stores.base_state_store import BaseStateStore
-from smarta2a.state_stores.inmemory_state_store import InMemoryStateStore
-from smarta2a.utils.types import StateData, SendTaskRequest
+from smarta2a.server.state_manager import StateManager
+from smarta2a.utils.types import StateData, SendTaskRequest, AgentCard, WebhookRequest, WebhookResponse, TextPart, DataPart, FilePart
+from smarta2a.client.a2a_client import A2AClient
 
 class A2AAgent:
     def __init__(
             self,
             name: str,
             model_provider: BaseLLMProvider,
-            history_update_strategy: HistoryUpdateStrategy = None,
-            state_store: BaseStateStore = None,
+            agent_card: AgentCard = None,
+            state_manager: StateManager = None,
         ):
         self.model_provider = model_provider
-        self.history_update_strategy = history_update_strategy or AppendStrategy()
-        self.state_store = state_store or InMemoryStateStore()
+        self.state_manager = state_manager
         self.app = SmartA2A(
             name=name,
-            history_update_strategy=self.history_update_strategy,
-            state_store=self.state_store
+            agent_card=agent_card,
+            state_manager=self.state_manager
         )
         self.__register_handlers()
 
@@ -32,12 +31,23 @@ class A2AAgent:
         @self.app.on_event("startup")
         async def on_startup():
             await self.model_provider.load()
-
-        @self.app.on_send_task()
+        
+        @self.app.app.get("/tasks")
+        async def get_tasks(fields: Optional[str] = Query(None)):
+            state_store = self.state_manager.get_store()
+            tasks_data = state_store.get_all_tasks(fields)
+            return JSONResponse(content=tasks_data)
+        
+        @self.app.on_send_task(forward_to_webhook=False)
         async def on_send_task(request: SendTaskRequest, state: StateData):
-            response = await self.model_provider.generate(state.history)
+            response = await self.model_provider.generate(state)
             return response
         
+        @self.app.webhook()
+        async def on_webhook(request: WebhookRequest, state: StateData):
+            response = await self.model_provider.generate(state)
+            return response
+
     def get_app(self):
         return self.app
 

smarta2a/agent/a2a_human.py

@@ -0,0 +1,56 @@
+# TODO: Implement a human agent that can be used to interact with the A2A server
+
+# Library imports
+from fastapi import Query
+from fastapi.responses import JSONResponse
+from typing import Optional
+
+# Local imports
+from smarta2a.server import SmartA2A
+from smarta2a.model_providers.base_llm_provider import BaseLLMProvider
+from smarta2a.server.state_manager import StateManager
+from smarta2a.utils.types import StateData, SendTaskRequest, AgentCard, WebhookRequest, WebhookResponse, TextPart, DataPart, FilePart
+from smarta2a.client.a2a_client import A2AClient
+
+class A2AHuman:
+    def __init__(
+            self,
+            name: str,
+            model_provider: BaseLLMProvider,
+            agent_card: AgentCard = None,
+            state_manager: StateManager = None,
+        ):
+        self.model_provider = model_provider
+        self.state_manager = state_manager
+        self.app = SmartA2A(
+            name=name,
+            agent_card=agent_card,
+            state_manager=self.state_manager
+        )
+        self.__register_handlers()
+
+    def __register_handlers(self):
+        @self.app.on_event("startup")
+        async def on_startup():
+            await self.model_provider.load()
+        
+        @self.app.app.get("/tasks")
+        async def get_tasks(fields: Optional[str] = Query(None)):
+            state_store = self.state_mgr.get_store()
+            tasks_data = state_store.get_all_tasks(fields)
+            return JSONResponse(content=tasks_data)
+        
+        @self.app.on_send_task(forward_to_webhook=True)
+        async def on_send_task(request: SendTaskRequest, state: StateData):
+            return "Give me some time to respond"
+        
+        @self.app.webhook()
+        async def on_webhook(request: WebhookRequest, state: StateData):
+            pass
+
+    def get_app(self):
+        return self.app
+
+
+    
+    

smarta2a/archive/smart_mcp_client.py

@@ -61,3 +61,50 @@ class SmartMCPClient:
         if session_id:
             headers["x-session-id"] = session_id
         return headers
+
+
+
+'''
+@self.app.app.post("/callback")
+        async def callback(request: CallbackResponse):
+            
+            # This callback updates the task history and the state data in the state store for that task
+            
+            # Get task id and task
+            task_id = request.result.id
+            task = request.result
+
+            # Get state data based on task id
+            state_data = self.state_store.get_state(task_id)
+
+            # Extract the messages from the task artifacts
+            messages = []
+            if task.artifacts:
+                for artifact in task.artifacts:
+                    messages.append(Message(
+                        role="agent",
+                        parts=artifact.parts,
+                        metadata=artifact.metadata
+                    ))
+
+            # Update the history
+            history = state_data.task.history.copy()
+            history.extend(messages)
+            state_data.task.history = history
+
+            # Update context history with a strategy - this is the history that will be passed to an LLM call
+            context_history = self.history_update_strategy.update_history(
+                existing_history=state_data.context_history,
+                new_messages=messages
+            )
+
+            # Update the task
+            task.history = history
+
+            # Update state store
+            self.state_store.update_state(task_id, StateData(task_id=task_id, task=task, context_history=context_history))
+
+            # Call on_send_task
+            await self.on_send_task(request)
+
+'''

smarta2a/archive/subscription_service.py

@@ -0,0 +1,85 @@
+# Library imports
+from typing import Optional, List, Dict, Any, AsyncGenerator, Union
+from datetime import datetime
+from collections import defaultdict
+from uuid import uuid4
+from fastapi.responses import StreamingResponse
+from sse_starlette.sse import EventSourceResponse
+
+# Local imports
+from smarta2a.server.handler_registry import HandlerRegistry
+from smarta2a.server.state_manager import StateManager
+from smarta2a.utils.types import (
+    Message, StateData, SendTaskStreamingRequest, SendTaskStreamingResponse,
+    TaskSendParams, A2AStatus, A2AStreamResponse, TaskStatusUpdateEvent,
+    TaskStatus, TaskState, TaskArtifactUpdateEvent, Artifact, TextPart,
+    FilePart, DataPart, FileContent, MethodNotFoundError, TaskNotFoundError,
+    InternalError
+)
+
+class SubscriptionService:
+    def __init__(self, registry: HandlerRegistry, state_mgr: StateManager):
+        self.registry = registry
+        self.state_mgr = state_mgr
+
+    async def subscribe(self, request: SendTaskStreamingRequest, state: Optional[StateData]) -> StreamingResponse:
+        handler = self.registry.get_subscription("tasks/sendSubscribe")
+        if not handler:
+            err = SendTaskStreamingResponse(jsonrpc="2.0", id=request.id, error=MethodNotFoundError()).model_dump_json()
+            return EventSourceResponse(err)
+
+        task_id = state.task_id if state else request.params.id or str(uuid4())
+        context_history = state.context_history.copy() if state else [request.params.message]
+        task_history = state.task_history.copy() if state else [request.params.message]
+        metadata = state.metadata.copy() if state else (request.params.metadata or {})
+
+        async def event_stream():
+            try:
+                events = handler(request, state) if state else handler(request)
+                async for ev in self._normalize(request.params, events, context_history.copy(), task_history.copy(), metadata.copy(), task_id):
+                    yield f"data: {ev}\n\n"
+            except Exception as e:
+                err = TaskNotFoundError() if 'not found' in str(e).lower() else InternalError(data=str(e))
+                msg = SendTaskStreamingResponse(jsonrpc="2.0", id=request.id, error=err).model_dump_json()
+                yield f"data: {msg}\n\n"
+
+        return StreamingResponse(event_stream(), media_type="text/event-stream; charset=utf-8")
+
+    async def _normalize(self, params: TaskSendParams, events: AsyncGenerator, context_history: List[Message], task_history: List[Message], metadata: Dict[str, Any], task_id: str) -> AsyncGenerator[Union[TaskStatusUpdateEvent, TaskArtifactUpdateEvent], None]:
+        async for evt in events:
+            if isinstance(evt, TaskArtifactUpdateEvent):
+                # Create agent message from artifact parts
+                agent_message = Message(
+                    role="agent",
+                    parts=[p for p in evt.artifact.parts],
+                    metadata=evt.artifact.metadata
+                )
+                
+                # Update task history (always append)
+                task_history.append(agent_message)
+                # Update context history using strategy
+                new_context_history = self.state_mgr.strategy.update_history(context_history, [agent_message])
+                
+                # Merge metadata
+                new_metadata = {
+                    **metadata,
+                    **(evt.artifact.metadata or {})
+                }
+
+                # Update state store if configured
+                if self.state_mgr.store:
+                    self.state_mgr.store.update_state(
+                        task_id=task_id,
+                        state_data=StateData(
+                            task_id=task_id,
+                            context_history=new_context_history,
+                            task_history=task_history,
+                            metadata=new_metadata
+                        )
+                    )
+
+                # Update streaming state
+                context_history = new_context_history
+                metadata = new_metadata
+
+            yield evt

smarta2a/{server → archive}/task_service.py

@@ -29,8 +29,9 @@ class TaskService:
         if not handler:
             return SendTaskResponse(id=request.id, error=MethodNotFoundError())
 
-        session_id = state.sessionId if state else request.params.sessionId or str(uuid4())
-        history = state.history.copy() if state else [request.params.message]
+        task_id = state.task_id if state else request.params.id or str(uuid4())
+        context_history = state.context_history.copy() if state else [request.params.message]
+        task_history = state.task_history.copy() if state else [request.params.message]
         metadata = state.metadata.copy() if state else (request.params.metadata or {})
 
         try:
@@ -40,18 +41,26 @@ class TaskService:
 
             task = self.builder.build(
                 content=raw,
-                task_id=request.params.id,
-                session_id=session_id,
+                task_id=task_id,
+                session_id=task_id,  # Use task_id as session_id for backward compatibility
                 metadata=metadata,
-                history=history
+                history=context_history  # Use context_history for task history
             )
 
             if task.artifacts:
                 parts = [p for a in task.artifacts for p in a.parts]
                 agent_msg = Message(role="agent", parts=parts, metadata=task.metadata)
-                new_hist = self.state_mgr.strategy.update_history(history, [agent_msg])
-                task.history = new_hist
-                self.state_mgr.update(StateData(sessionId=session_id, history=new_hist, metadata=metadata))
+                # Update task history (always append)
+                task_history.append(agent_msg)
+                # Update context history using strategy
+                new_context_history = self.state_mgr.strategy.update_history(context_history, [agent_msg])
+                task.history = new_context_history  # Use context_history for task history
+                self.state_mgr.update(StateData(
+                    task_id=task_id,
+                    context_history=new_context_history,
+                    task_history=task_history,
+                    metadata=metadata
+                ))
 
             return SendTaskResponse(id=request.id, result=task)
         except JSONRPCError as e:

smarta2a/client/a2a_client.py

@@ -23,6 +23,9 @@ from smarta2a.utils.types import (
     CancelTaskResponse,
     SetTaskPushNotificationResponse,
     GetTaskPushNotificationResponse,
+    WebhookRequest,
+    WebhookResponse,
+    Task,
 )
 from smarta2a.utils.task_request_builder import TaskRequestBuilder
 
@@ -34,30 +37,30 @@ class A2AClient:
         elif url:
             self.url = url
         else:
-            raise ValueError("Must provide either agent_card or url")
+            pass
 
     async def send(
         self,
         *,
         id: str,
         role: Literal["user", "agent"] = "user",
-        text: str | None = None,
+        text: str,
         data: dict[str, Any] | None = None,
         file_uri: str | None = None,
-        session_id: str | None = None,
+        sessionId: str | None = None,
         accepted_output_modes: list[str] | None = None,
         push_notification: PushNotificationConfig | None = None,
         history_length: int | None = None,
         metadata: dict[str, Any] | None = None,
     ):
-        """Send a task to another Agent"""
+        """Send a task to another Agent."""
         params = TaskRequestBuilder.build_send_task_request(
             id=id,
             role=role,
             text=text,
             data=data,
             file_uri=file_uri,
-            session_id=session_id,
+            session_id=sessionId, # Need to amend the TaskRequestBuilder at a later time to take sessionId not session_id
             accepted_output_modes=accepted_output_modes,
             push_notification=push_notification,
             history_length=history_length,
@@ -80,7 +83,7 @@ class A2AClient:
         history_length: int | None = None,
         metadata: dict[str, Any] | None = None,
     ):
-        """Send to another Agent and receive a stream of responses"""
+        """Send to another Agent and receive a stream of responses."""
         params = TaskRequestBuilder.build_send_task_request(
             id=id,
             role=role,
@@ -152,6 +155,16 @@ class A2AClient:
         req = TaskRequestBuilder.get_push_notification(id, metadata)
         raw = await self._send_request(req)
         return GetTaskPushNotificationResponse(**raw)
+
+    async def send_to_webhook(
+        self,
+        webhook_url: str,
+        id: str,
+        task: Task
+    ):
+        """Send a task to another Agent"""
+        request = WebhookRequest(id=id, result=task)
+        return WebhookResponse(**await self._send_webhook_request(webhook_url, request))
         
             
     async def _send_request(self, request: JSONRPCRequest) -> dict[str, Any]:
@@ -167,6 +180,20 @@ class A2AClient:
                 raise A2AClientHTTPError(e.response.status_code, str(e)) from e
             except json.JSONDecodeError as e:
                 raise A2AClientJSONError(str(e)) from e
+    
+    async def _send_webhook_request(self, webhook_url: str, request: WebhookRequest) -> dict[str, Any]:
+        async with httpx.AsyncClient() as client:
+            try:
+                # Image generation could take time, adding timeout
+                response = await client.post(
+                    webhook_url, json=request.model_dump(), timeout=30
+                )
+                response.raise_for_status()
+                return response.json()
+            except httpx.HTTPStatusError as e:
+                raise A2AClientHTTPError(e.response.status_code, str(e)) from e
+            except json.JSONDecodeError as e:
+                raise A2AClientJSONError(str(e)) from e
             
     async def _send_streaming_request(self, request: JSONRPCRequest) -> AsyncIterable[SendTaskStreamingResponse]:
         with httpx.Client(timeout=None) as client:

smarta2a/history_update_strategies/rolling_window_strategy.py

@@ -0,0 +1,16 @@
+# Library imports
+from typing import List
+
+# Local imports
+from smarta2a.utils.types import Message
+
+class RollingWindowStrategy:
+    def __init__(self, window_size: int):
+        if window_size < 1:
+            raise ValueError("window_size must be at least 1")
+        self.window_size = window_size
+
+    """Default append behavior"""
+    def update_history(self, existing_history: List[Message], new_messages: List[Message]) -> List[Message]:
+        combined = existing_history + new_messages
+        return combined[-self.window_size:]

smarta2a/model_providers/__init__.py

@@ -1,5 +1,5 @@
 """
 Model provider implementations for different AI models.
 """
-
+ 
 # This package is currently empty but will contain model provider implementations 

smarta2a/model_providers/base_llm_provider.py

@@ -3,13 +3,13 @@ from abc import ABC, abstractmethod
 from typing import AsyncGenerator, List
 
 # Local imports
-from smarta2a.utils.types import Message
+from smarta2a.utils.types import StateData
 
 class BaseLLMProvider(ABC):
     @abstractmethod
-    async def generate(self, messages: List[Message], **kwargs) -> str:
+    async def generate(self, state: StateData, **kwargs) -> str:
         pass
     
     @abstractmethod
-    async def generate_stream(self, messages: List[Message], **kwargs) -> AsyncGenerator[str, None]:
+    async def generate_stream(self, state: StateData, **kwargs) -> AsyncGenerator[str, None]:
         pass