a2a-lite 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

a2a_lite/human_loop.py

@@ -1,284 +0,0 @@
-"""
-Human-in-the-loop support (OPTIONAL).
-
-Allows agents to ask users for clarification mid-task.
-Uses A2A's "input-required" task state.
-
-Example (simple - no human loop needed):
-    @agent.skill("greet")
-    async def greet(name: str) -> str:
-        return f"Hello, {name}!"
-
-Example (with human-in-the-loop - opt-in):
-    @agent.skill("book_flight")
-    async def book_flight(destination: str, ctx: InteractionContext) -> str:
-        # Ask user for date
-        date = await ctx.ask("What date do you want to travel?")
-
-        # Ask for confirmation with options
-        confirm = await ctx.ask(
-            f"Book flight to {destination} on {date}?",
-            options=["Yes", "No", "Change date"]
-        )
-
-        if confirm == "Yes":
-            return f"Booked flight to {destination} on {date}!"
-        elif confirm == "Change date":
-            new_date = await ctx.ask("Enter new date:")
-            return f"Booked flight to {destination} on {new_date}!"
-        else:
-            return "Booking cancelled."
-"""
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any, Callable, Dict, List, Optional, Union
-from uuid import uuid4
-import asyncio
-
-
-@dataclass
-class InputRequest:
-    """Request for user input."""
-    id: str
-    prompt: str
-    options: Optional[List[str]] = None
-    input_type: str = "text"  # text, choice, confirm, file
-    required: bool = True
-    default: Optional[str] = None
-    metadata: Dict[str, Any] = field(default_factory=dict)
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "id": self.id,
-            "prompt": self.prompt,
-            "options": self.options,
-            "type": self.input_type,
-            "required": self.required,
-            "default": self.default,
-            "metadata": self.metadata,
-        }
-
-
-@dataclass
-class InputResponse:
-    """User's response to input request."""
-    request_id: str
-    value: Any
-    metadata: Dict[str, Any] = field(default_factory=dict)
-
-
-class InteractionContext:
-    """
-    Context for human-in-the-loop interactions.
-
-    Passed to skills that need to ask users questions.
-
-    Example:
-        @agent.skill("wizard")
-        async def wizard(ctx: InteractionContext) -> str:
-            name = await ctx.ask("What's your name?")
-            age = await ctx.ask("How old are you?", input_type="number")
-            confirm = await ctx.confirm(f"Create profile for {name}, age {age}?")
-
-            if confirm:
-                return f"Created profile for {name}!"
-            return "Cancelled."
-    """
-
-    def __init__(
-        self,
-        task_id: str,
-        event_queue=None,
-        response_handler: Optional[Callable] = None,
-    ):
-        self.task_id = task_id
-        self._event_queue = event_queue
-        self._response_handler = response_handler
-        self._pending_requests: Dict[str, asyncio.Future] = {}
-
-    async def ask(
-        self,
-        prompt: str,
-        options: Optional[List[str]] = None,
-        input_type: str = "text",
-        required: bool = True,
-        default: Optional[str] = None,
-        timeout: Optional[float] = None,
-    ) -> str:
-        """
-        Ask the user a question and wait for response.
-
-        Args:
-            prompt: Question to ask
-            options: List of options (for choice type)
-            input_type: "text", "choice", "number", "file"
-            required: Whether input is required
-            default: Default value if not required
-            timeout: Timeout in seconds
-
-        Returns:
-            User's response
-
-        Example:
-            name = await ctx.ask("What's your name?")
-            choice = await ctx.ask("Pick one:", options=["A", "B", "C"])
-        """
-        request = InputRequest(
-            id=uuid4().hex,
-            prompt=prompt,
-            options=options,
-            input_type="choice" if options else input_type,
-            required=required,
-            default=default,
-        )
-
-        # Create future for response
-        future: asyncio.Future = asyncio.Future()
-        self._pending_requests[request.id] = future
-
-        # Send input-required event
-        await self._send_input_request(request)
-
-        # Wait for response
-        try:
-            if timeout:
-                response = await asyncio.wait_for(future, timeout=timeout)
-            else:
-                response = await future
-            return response.value
-        except asyncio.TimeoutError:
-            if default is not None:
-                return default
-            raise TimeoutError(f"No response received for: {prompt}")
-        finally:
-            self._pending_requests.pop(request.id, None)
-
-    async def confirm(
-        self,
-        prompt: str,
-        yes_label: str = "Yes",
-        no_label: str = "No",
-    ) -> bool:
-        """
-        Ask for yes/no confirmation.
-
-        Example:
-            if await ctx.confirm("Are you sure?"):
-                do_something()
-        """
-        response = await self.ask(
-            prompt,
-            options=[yes_label, no_label],
-            input_type="choice",
-        )
-        return response == yes_label
-
-    async def choose(
-        self,
-        prompt: str,
-        options: List[str],
-        allow_multiple: bool = False,
-    ) -> Union[str, List[str]]:
-        """
-        Ask user to choose from options.
-
-        Example:
-            color = await ctx.choose("Pick a color:", ["Red", "Blue", "Green"])
-        """
-        response = await self.ask(prompt, options=options, input_type="choice")
-        if allow_multiple and isinstance(response, str):
-            return [response]
-        return response
-
-    async def _send_input_request(self, request: InputRequest) -> None:
-        """Send input-required event via SSE."""
-        if self._event_queue:
-            from a2a.utils import new_agent_text_message
-            import json
-
-            msg = json.dumps({
-                "_type": "input_required",
-                "task_id": self.task_id,
-                "request": request.to_dict(),
-            })
-            await self._event_queue.enqueue_event(new_agent_text_message(msg))
-
-    def handle_response(self, request_id: str, value: Any) -> bool:
-        """
-        Handle incoming response from user.
-
-        Called by the executor when user responds.
-        """
-        future = self._pending_requests.get(request_id)
-        if future and not future.done():
-            response = InputResponse(request_id=request_id, value=value)
-            future.set_result(response)
-            return True
-        return False
-
-
-class ConversationMemory:
-    """
-    Simple conversation memory for multi-turn interactions.
-
-    Example:
-        @agent.skill("chat")
-        async def chat(message: str, memory: ConversationMemory) -> str:
-            # Get conversation history
-            history = memory.get_messages()
-
-            # Add user message
-            memory.add_user(message)
-
-            # Generate response (using history for context)
-            response = await generate_response(message, history)
-
-            # Add assistant response
-            memory.add_assistant(response)
-
-            return response
-    """
-
-    def __init__(self, max_messages: int = 100):
-        self._messages: List[Dict[str, str]] = []
-        self._max_messages = max_messages
-        self._metadata: Dict[str, Any] = {}
-
-    def add_user(self, content: str) -> None:
-        """Add user message."""
-        self._add_message("user", content)
-
-    def add_assistant(self, content: str) -> None:
-        """Add assistant message."""
-        self._add_message("assistant", content)
-
-    def add_system(self, content: str) -> None:
-        """Add system message."""
-        self._add_message("system", content)
-
-    def _add_message(self, role: str, content: str) -> None:
-        self._messages.append({"role": role, "content": content})
-        # Trim if over limit
-        if len(self._messages) > self._max_messages:
-            self._messages = self._messages[-self._max_messages:]
-
-    def get_messages(self) -> List[Dict[str, str]]:
-        """Get all messages."""
-        return list(self._messages)
-
-    def get_last(self, n: int = 10) -> List[Dict[str, str]]:
-        """Get last n messages."""
-        return self._messages[-n:]
-
-    def clear(self) -> None:
-        """Clear all messages."""
-        self._messages.clear()
-
-    def set_metadata(self, key: str, value: Any) -> None:
-        """Set metadata."""
-        self._metadata[key] = value
-
-    def get_metadata(self, key: str, default: Any = None) -> Any:
-        """Get metadata."""
-        return self._metadata.get(key, default)

a2a_lite/webhooks.py

@@ -1,228 +0,0 @@
-"""
-Webhook and push notification support for A2A Lite.
-
-Simplifies sending notifications when tasks complete:
-
-    @agent.on_complete
-    async def notify(task_id, result):
-        await webhook.post(callback_url, result)
-"""
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any, Callable, Dict, List, Optional
-import asyncio
-import json
-
-
-@dataclass
-class WebhookConfig:
-    """Configuration for a webhook endpoint."""
-    url: str
-    headers: Dict[str, str] = field(default_factory=dict)
-    retry_count: int = 3
-    retry_delay: float = 1.0
-    timeout: float = 30.0
-
-
-class WebhookClient:
-    """
-    Simple webhook client for sending notifications.
-
-    Example:
-        webhook = WebhookClient()
-
-        # Send a notification
-        await webhook.post("https://example.com/callback", {"status": "done"})
-
-        # With retries
-        await webhook.post(url, data, retry=3)
-    """
-
-    def __init__(self, default_headers: Optional[Dict[str, str]] = None):
-        self.default_headers = default_headers or {}
-
-    async def post(
-        self,
-        url: str,
-        data: Any,
-        headers: Optional[Dict[str, str]] = None,
-        retry: int = 0,
-        timeout: float = 30.0,
-    ) -> Dict[str, Any]:
-        """
-        Send a POST request to a webhook URL.
-
-        Args:
-            url: The webhook URL
-            data: Data to send (will be JSON serialized)
-            headers: Additional headers
-            retry: Number of retries on failure
-            timeout: Request timeout in seconds
-
-        Returns:
-            Response data
-        """
-        import httpx
-
-        all_headers = {**self.default_headers, **(headers or {})}
-        all_headers.setdefault("Content-Type", "application/json")
-
-        last_error = None
-        for attempt in range(retry + 1):
-            try:
-                async with httpx.AsyncClient(timeout=timeout) as client:
-                    response = await client.post(
-                        url,
-                        json=data if isinstance(data, (dict, list)) else {"data": data},
-                        headers=all_headers,
-                    )
-                    response.raise_for_status()
-                    return {
-                        "status": response.status_code,
-                        "success": True,
-                        "data": response.json() if response.content else None,
-                    }
-            except Exception as e:
-                last_error = e
-                if attempt < retry:
-                    await asyncio.sleep(1.0 * (attempt + 1))
-
-        return {
-            "success": False,
-            "error": str(last_error),
-            "attempts": retry + 1,
-        }
-
-    async def notify(
-        self,
-        config: WebhookConfig,
-        event: str,
-        data: Any,
-    ) -> Dict[str, Any]:
-        """
-        Send a notification using a WebhookConfig.
-
-        Args:
-            config: Webhook configuration
-            event: Event name
-            data: Event data
-
-        Returns:
-            Response data
-        """
-        payload = {
-            "event": event,
-            "data": data,
-        }
-        return await self.post(
-            config.url,
-            payload,
-            headers=config.headers,
-            retry=config.retry_count,
-            timeout=config.timeout,
-        )
-
-
-class NotificationManager:
-    """
-    Manages push notifications for agent tasks.
-
-    Example:
-        notifications = NotificationManager()
-
-        # Register a callback URL for a task
-        notifications.register("task-123", "https://example.com/callback")
-
-        # Later, when task completes
-        await notifications.notify_complete("task-123", result)
-    """
-
-    def __init__(self):
-        self._callbacks: Dict[str, WebhookConfig] = {}
-        self._client = WebhookClient()
-
-    def register(
-        self,
-        task_id: str,
-        callback_url: str,
-        headers: Optional[Dict[str, str]] = None,
-    ) -> None:
-        """Register a callback URL for a task."""
-        self._callbacks[task_id] = WebhookConfig(
-            url=callback_url,
-            headers=headers,
-        )
-
-    def unregister(self, task_id: str) -> None:
-        """Remove a callback registration."""
-        self._callbacks.pop(task_id, None)
-
-    async def notify_complete(
-        self,
-        task_id: str,
-        result: Any,
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Notify that a task has completed.
-
-        Args:
-            task_id: The task ID
-            result: The task result
-
-        Returns:
-            Webhook response or None if no callback registered
-        """
-        config = self._callbacks.get(task_id)
-        if not config:
-            return None
-
-        response = await self._client.notify(
-            config,
-            event="task.completed",
-            data={"task_id": task_id, "result": result},
-        )
-
-        # Clean up after notification
-        self.unregister(task_id)
-        return response
-
-    async def notify_error(
-        self,
-        task_id: str,
-        error: str,
-    ) -> Optional[Dict[str, Any]]:
-        """Notify that a task has failed."""
-        config = self._callbacks.get(task_id)
-        if not config:
-            return None
-
-        response = await self._client.notify(
-            config,
-            event="task.failed",
-            data={"task_id": task_id, "error": error},
-        )
-
-        self.unregister(task_id)
-        return response
-
-    async def notify_progress(
-        self,
-        task_id: str,
-        progress: float,
-        message: Optional[str] = None,
-    ) -> Optional[Dict[str, Any]]:
-        """Notify task progress (0.0 to 1.0)."""
-        config = self._callbacks.get(task_id)
-        if not config:
-            return None
-
-        return await self._client.notify(
-            config,
-            event="task.progress",
-            data={
-                "task_id": task_id,
-                "progress": progress,
-                "message": message,
-            },
-        )

a2a_lite-0.2.2.dist-info/RECORD

@@ -1,19 +0,0 @@
-a2a_lite/__init__.py,sha256=-uZfl-CoWKt4xFSmda3TEBmPB7pRA71u9C4HkK8Pavs,3520
-a2a_lite/agent.py,sha256=OrIzIaJLv7O55G1jrSl81pNem9S7kD47QDOzxISAmw0,17793
-a2a_lite/auth.py,sha256=A1AMncM0cuWEAcysjumAhjd0lI_jMLmJpeYWuAPj30A,10181
-a2a_lite/cli.py,sha256=chLmUrWPxXmXU75LO8yhN5HP0rct3yN8W_i_txTvoJA,9043
-a2a_lite/decorators.py,sha256=RDekZdDJQR8124zX0lvTinaU7iJdNjNHaNPop17_gmg,1116
-a2a_lite/discovery.py,sha256=BxpiJAUDxIyI2gvsLhjmHte5c9ax5Qf1hbBQnyAmxLQ,4508
-a2a_lite/executor.py,sha256=gC_9mzoGalUJMZUio-SQeXcoZvOU4LR69eK9ikncJwQ,13628
-a2a_lite/human_loop.py,sha256=XAqxp-k8I7TNyuLqqNmLEqABHqcAUiKYCL8n3W5StaY,8685
-a2a_lite/middleware.py,sha256=c6jb9aFfyTf-JY6KjqaSgFJmpzqbHLC6Q1h9NNteqzo,5545
-a2a_lite/parts.py,sha256=qVRiD-H9_NlMPk-R0gTUiGVQ77E2poiuBWAUyAyAoTI,6177
-a2a_lite/streaming.py,sha256=RFv9EJYnhwkT0h1Wovkj4EXwFzCgHdaA-h7WpPaaONo,2329
-a2a_lite/tasks.py,sha256=UpmDP-VGIQ1LodBNq4zx2pJElQ31gOJOAduHFBVyxOA,7039
-a2a_lite/testing.py,sha256=M9IbLA6oUz1DokJ9Sc_r0gK43NNkU78IVkiBRuDFFCU,9393
-a2a_lite/utils.py,sha256=AFLYQ4J-F7H_HeYWAeg8H3p9EOdDv4dOpju_ebrU5PI,3934
-a2a_lite/webhooks.py,sha256=TNhDlG84rrP_gC2pQ-op5xo01p5Z9sm_ZgQIrJRI7OY,6095
-a2a_lite-0.2.2.dist-info/METADATA,sha256=o74kDuPcSpG1A82qVROqwqMMTTvR95vigXwtx64OeCU,12657
-a2a_lite-0.2.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-a2a_lite-0.2.2.dist-info/entry_points.txt,sha256=BONfFqZbCntNal2iwlTJAE09gCUvurfvqslMYVYh4is,46
-a2a_lite-0.2.2.dist-info/RECORD,,