a2a-lite 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

a2a_lite/__init__.py

@@ -1,5 +1,5 @@
 """
-A2A Lite - Simple by default, powerful when needed.
+A2A Lite - Build A2A agents in 8 lines. Add enterprise features when you need them.
 
 SIMPLE (8 lines):
     from a2a_lite import Agent
@@ -43,14 +43,6 @@ WITH TASK TRACKING (opt-in):
         await task.update("working", progress=0.5)
         return "done"
 
-WITH HUMAN-IN-THE-LOOP (opt-in):
-    from a2a_lite.human_loop import InteractionContext
-
-    @agent.skill("wizard")
-    async def wizard(ctx: InteractionContext) -> str:
-        name = await ctx.ask("What's your name?")
-        return f"Hello, {name}!"
-
 WITH FILES (opt-in):
     from a2a_lite.parts import FilePart
 
@@ -60,13 +52,12 @@ WITH FILES (opt-in):
         return summarize(text)
 """
 
-# Core - always available
+# Core
 from .agent import Agent
 from .decorators import SkillDefinition
-from .discovery import AgentDiscovery, DiscoveredAgent
 from .testing import AgentTestClient, AsyncAgentTestClient, TestResult
 
-# Middleware - always available
+# Middleware
 from .middleware import (
     MiddlewareContext,
     MiddlewareChain,
@@ -76,22 +67,13 @@ from .middleware import (
     rate_limit_middleware,
 )
 
-# Webhooks - always available
-from .webhooks import WebhookClient, WebhookConfig, NotificationManager
-
-# Streaming - always available
-from .streaming import StreamingResponse
-
-# Parts - opt-in for multi-modal
+# Parts (multi-modal)
 from .parts import TextPart, FilePart, DataPart, Artifact
 
-# Tasks - opt-in for task lifecycle
+# Tasks
 from .tasks import TaskContext, TaskState, TaskStatus, Task, TaskStore
 
-# Human-in-the-loop - opt-in
-from .human_loop import InteractionContext, ConversationMemory
-
-# Auth - opt-in
+# Auth
 from .auth import (
     AuthProvider,
     AuthResult,
@@ -102,14 +84,12 @@ from .auth import (
     require_auth,
 )
 
-__version__ = "0.2.1"
+__version__ = "0.2.3"
 
 __all__ = [
     # Core
     "Agent",
     "SkillDefinition",
-    "AgentDiscovery",
-    "DiscoveredAgent",
     # Testing
     "AgentTestClient",
     "AsyncAgentTestClient",
@@ -121,12 +101,6 @@ __all__ = [
     "timing_middleware",
     "retry_middleware",
     "rate_limit_middleware",
-    # Webhooks
-    "WebhookClient",
-    "WebhookConfig",
-    "NotificationManager",
-    # Streaming
-    "StreamingResponse",
     # Parts (multi-modal)
     "TextPart",
     "FilePart",
@@ -138,9 +112,6 @@ __all__ = [
     "TaskStatus",
     "Task",
     "TaskStore",
-    # Human-in-the-loop
-    "InteractionContext",
-    "ConversationMemory",
     # Auth
     "AuthProvider",
     "AuthResult",

a2a_lite/agent.py

@@ -29,7 +29,6 @@ from .decorators import SkillDefinition
 from .utils import type_to_json_schema, extract_function_schemas, _is_or_subclass
 from .middleware import MiddlewareChain, MiddlewareContext
 from .streaming import is_generator_function
-from .webhooks import NotificationManager, WebhookClient
 
 
 @dataclass
@@ -73,12 +72,6 @@ class Agent:
         async def process(data: str, task: TaskContext) -> str:
             await task.update("working", progress=0.5)
             return "done"
-
-    WITH HUMAN-IN-THE-LOOP (optional):
-        @agent.skill("wizard")
-        async def wizard(ctx: InteractionContext) -> str:
-            name = await ctx.ask("What's your name?")
-            return f"Hello, {name}!"
     """
     name: str
     description: str
@@ -98,10 +91,7 @@ class Agent:
         self._on_startup: List[Callable] = []
         self._on_shutdown: List[Callable] = []
         self._on_complete: List[Callable] = []
-        self._discovery = None
         self._middleware = MiddlewareChain()
-        self._notifications = NotificationManager()
-        self._webhook = WebhookClient()
         self._has_streaming = False
 
         # Setup optional task store
@@ -146,12 +136,6 @@ class Agent:
             async def process(data: str, task: TaskContext) -> str:
                 await task.update("working", progress=0.5)
                 return "done"
-
-        With human-in-the-loop (opt-in):
-            @agent.skill("wizard")
-            async def wizard(ctx: InteractionContext) -> str:
-                name = await ctx.ask("What's your name?")
-                return f"Hello, {name}!"
         """
         def decorator(func: Callable) -> Callable:
             skill_name = name or func.__name__
@@ -169,12 +153,12 @@ class Agent:
             # Detect special parameter types using proper type introspection
             import typing
             from .tasks import TaskContext as _TaskContext
-            from .human_loop import InteractionContext as _InteractionContext
+            from .auth import AuthResult as _AuthResult
 
             needs_task_context = False
-            needs_interaction = False
+            needs_auth = False
             task_context_param: str | None = None
-            interaction_param: str | None = None
+            auth_param: str | None = None
 
             try:
                 resolved_hints = typing.get_type_hints(func)
@@ -187,9 +171,14 @@ class Agent:
                 if _is_or_subclass(hint, _TaskContext):
                     needs_task_context = True
                     task_context_param = param_name
-                elif _is_or_subclass(hint, _InteractionContext):
-                    needs_interaction = True
-                    interaction_param = param_name
+                elif _is_or_subclass(hint, _AuthResult):
+                    needs_auth = True
+                    auth_param = param_name
+
+            # Also detect require_auth decorator
+            if getattr(func, '__requires_auth__', False) and not needs_auth:
+                needs_auth = True
+                auth_param = auth_param or "auth"
 
             # Extract schemas
             input_schema, output_schema = extract_function_schemas(func)
@@ -204,9 +193,9 @@ class Agent:
                 is_async=asyncio.iscoroutinefunction(func) or is_streaming,
                 is_streaming=is_streaming,
                 needs_task_context=needs_task_context,
-                needs_interaction=needs_interaction,
+                needs_auth=needs_auth,
                 task_context_param=task_context_param,
-                interaction_param=interaction_param,
+                auth_param=auth_param,
             )
 
             self._skills[skill_name] = skill_def
@@ -251,16 +240,6 @@ class Agent:
         self._on_complete.append(func)
         return func
 
-    @property
-    def webhook(self) -> WebhookClient:
-        """Get the webhook client for sending notifications."""
-        return self._webhook
-
-    @property
-    def notifications(self) -> NotificationManager:
-        """Get the notification manager for push notifications."""
-        return self._notifications
-
     def build_agent_card(self, host: str = "localhost", port: int = 8787) -> AgentCard:
         """Generate A2A-compliant Agent Card from registered skills."""
         skills = []
@@ -278,12 +257,6 @@ class Agent:
 
         url = self.url or f"http://{host}:{port}"
 
-        # Check if any skills need human-in-the-loop
-        has_input_required = any(
-            getattr(s, 'needs_interaction', False)
-            for s in self._skills.values()
-        )
-
         return AgentCard(
             name=self.name,
             description=self.description,
@@ -302,9 +275,7 @@ class Agent:
         self,
         host: str = "0.0.0.0",
         port: int = 8787,
-        reload: bool = False,
         log_level: str = "info",
-        enable_discovery: bool = False,
     ) -> None:
         """
         Start the A2A server.
@@ -313,7 +284,7 @@ class Agent:
             agent.run()
 
         With options:
-            agent.run(port=9000, enable_discovery=True)
+            agent.run(port=9000)
         """
         from rich.console import Console
         from rich.panel import Panel
@@ -349,8 +320,7 @@ class Agent:
         # Build display info
         skills_list = "\n".join([
             f"  • {s.name}: {s.description}" +
-            (" [streaming]" if getattr(s, 'is_streaming', False) else "") +
-            (" [interactive]" if getattr(s, 'needs_interaction', False) else "")
+            (" [streaming]" if getattr(s, 'is_streaming', False) else "")
             for s in self._skills.values()
         ])
         if not skills_list:
@@ -362,8 +332,6 @@ class Agent:
             features.append(f"{len(self._middleware._middlewares)} middleware")
         if self._has_streaming:
             features.append("streaming")
-        if self._on_complete:
-            features.append("webhooks")
         if self.auth:
             features.append("auth")
         if self._task_store:
@@ -383,22 +351,14 @@ class Agent:
         ))
 
         # Run startup hooks
-        for hook in self._on_startup:
-            if asyncio.iscoroutinefunction(hook):
-                asyncio.get_event_loop().run_until_complete(hook())
-            else:
-                hook()
-
-        # Enable discovery if requested
-        if enable_discovery:
-            from .discovery import AgentDiscovery
-            self._discovery = AgentDiscovery()
-            self._discovery.register(
-                name=self.name,
-                port=port,
-                properties={"version": self.version},
-            )
-            console.print(f"[dim]mDNS discovery enabled for {self.name}[/]")
+        async def _run_startup():
+            for hook in self._on_startup:
+                if asyncio.iscoroutinefunction(hook):
+                    await hook()
+                else:
+                    hook()
+        if self._on_startup:
+            asyncio.run(_run_startup())
 
         # Production mode warning
         if self.production:
@@ -415,8 +375,6 @@ class Agent:
         # Add CORS middleware if configured
         if self.cors_origins is not None:
             from starlette.middleware.cors import CORSMiddleware
-            from starlette.middleware import Middleware as StarletteMiddleware
-            # Wrap the existing app with CORS
             app.add_middleware(
                 CORSMiddleware,
                 allow_origins=self.cors_origins,
@@ -434,15 +392,14 @@ class Agent:
             )
         finally:
             # Run shutdown hooks
-            for hook in self._on_shutdown:
-                if asyncio.iscoroutinefunction(hook):
-                    asyncio.get_event_loop().run_until_complete(hook())
-                else:
-                    hook()
-
-            # Unregister discovery
-            if self._discovery:
-                self._discovery.unregister()
+            async def _run_shutdown():
+                for hook in self._on_shutdown:
+                    if asyncio.iscoroutinefunction(hook):
+                        await hook()
+                    else:
+                        hook()
+            if self._on_shutdown:
+                asyncio.run(_run_shutdown())
 
     async def call_remote(
         self,

a2a_lite/auth.py

@@ -222,7 +222,7 @@ class OAuth2Auth(AuthProvider):
             audience="my-agent",
         )
 
-    Requires: pip install pyjwt[crypto]
+    Requires: pip install a2a-lite[oauth]
     """
 
     def __init__(
@@ -277,7 +277,7 @@ class OAuth2Auth(AuthProvider):
 
         except ImportError:
             return AuthResult.failure(
-                "OAuth2 requires pyjwt: pip install pyjwt[crypto]"
+                "OAuth2 requires pyjwt: pip install a2a-lite[oauth]"
             )
         except Exception as e:
             return AuthResult.failure(f"Token validation failed: {str(e)}")

a2a_lite/cli.py

@@ -75,7 +75,7 @@ version = "0.1.0"
 description = "A2A Agent: {name}"
 requires-python = ">=3.10"
 dependencies = [
-    "a2a-lite>=0.2.1",
+    "a2a-lite>=0.2.3",
 ]
 '''
     (project_path / "pyproject.toml").write_text(pyproject)
@@ -232,51 +232,10 @@ def test(
         raise typer.Exit(1)
 
 
-@app.command()
-def discover(
-    timeout: float = typer.Option(5.0, help="Discovery timeout in seconds"),
-):
-    """
-    Discover A2A agents on the local network.
-
-    Uses mDNS to find agents advertising themselves.
-    """
-    from .discovery import AgentDiscovery
-
-    async def _discover():
-        console.print("[dim]Scanning local network...[/]\n")
-
-        discovery = AgentDiscovery()
-        agents = await discovery.discover(timeout=timeout)
-
-        if not agents:
-            console.print("[yellow]No agents found.[/]")
-            console.print("[dim]Make sure agents are running with discovery enabled (enable_discovery=True).[/]")
-            return
-
-        table = Table(title=f"🔍 Found {len(agents)} Agent(s)")
-        table.add_column("Name", style="cyan")
-        table.add_column("URL", style="blue")
-        table.add_column("Properties", style="dim")
-
-        for agent in agents:
-            table.add_row(
-                agent.name,
-                agent.url,
-                json.dumps(agent.properties) if agent.properties else "-",
-            )
-
-        console.print(table)
-
-    asyncio.run(_discover())
-
-
 @app.command()
 def serve(
     file: Path = typer.Argument(..., help="Python file containing the agent"),
     port: int = typer.Option(8787, help="Port to run on"),
-    reload: bool = typer.Option(False, "--reload", "-r", help="Enable hot reload"),
-    discovery: bool = typer.Option(False, "--discovery", "-d", help="Enable mDNS discovery"),
 ):
     """
     Run an agent from a Python file.
@@ -312,7 +271,7 @@ def serve(
         raise typer.Exit(1)
 
     agent = module.agent
-    agent.run(port=port, reload=reload, enable_discovery=discovery)
+    agent.run(port=port)
 
 
 @app.command()

a2a_lite/decorators.py

@@ -17,9 +17,9 @@ class SkillDefinition:
     is_async: bool = False
     is_streaming: bool = False
     needs_task_context: bool = False
-    needs_interaction: bool = False
+    needs_auth: bool = False
     task_context_param: Optional[str] = None
-    interaction_param: Optional[str] = None
+    auth_param: Optional[str] = None
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary for serialization."""
@@ -30,5 +30,4 @@ class SkillDefinition:
             "input_schema": self.input_schema,
             "output_schema": self.output_schema,
             "is_streaming": self.is_streaming,
-            "needs_interaction": self.needs_interaction,
         }

a2a_lite/executor.py

@@ -59,21 +59,22 @@ class LiteAgentExecutor(AgentExecutor):
         from a2a.utils import new_agent_text_message
 
         try:
-            # Authenticate the request
+            # Authenticate the request (always run to produce auth_result for injection)
+            auth_result = None
             if self.auth_provider:
                 from .auth import AuthRequest, NoAuth
-                if not isinstance(self.auth_provider, NoAuth):
-                    headers = {}
-                    if context.call_context and context.call_context.state:
-                        headers = context.call_context.state.get('headers', {})
-                    auth_request = AuthRequest(headers=headers)
-                    auth_result = await self.auth_provider.authenticate(auth_request)
-                    if not auth_result.authenticated:
-                        error_msg = json.dumps({
-                            "error": auth_result.error or "Authentication failed",
-                        })
-                        await event_queue.enqueue_event(new_agent_text_message(error_msg))
-                        return
+                headers = {}
+                if context.call_context and context.call_context.state:
+                    headers = context.call_context.state.get('headers', {})
+                auth_request = AuthRequest(headers=headers)
+                auth_result = await self.auth_provider.authenticate(auth_request)
+                # Reject unauthenticated requests (unless NoAuth)
+                if not isinstance(self.auth_provider, NoAuth) and not auth_result.authenticated:
+                    error_msg = json.dumps({
+                        "error": auth_result.error or "Authentication failed",
+                    })
+                    await event_queue.enqueue_event(new_agent_text_message(error_msg))
+                    return
 
             # Extract message and parts
             message, parts = self._extract_message_and_parts(context)
@@ -88,9 +89,10 @@ class LiteAgentExecutor(AgentExecutor):
                 message=message,
             )
 
-            # Store parts in metadata for skill access
+            # Store parts and auth result in metadata for skill access
             ctx.metadata["parts"] = parts
             ctx.metadata["event_queue"] = event_queue
+            ctx.metadata["auth_result"] = auth_result
 
             # Define final handler
             async def final_handler(ctx: MiddlewareContext) -> Any:
@@ -166,12 +168,9 @@ class LiteAgentExecutor(AgentExecutor):
             param_name = skill_def.task_context_param or "task"
             params[param_name] = task_ctx
 
-        if skill_def.needs_interaction:
-            from .human_loop import InteractionContext
-            task_id = metadata.get("task_id", "unknown")
-            interaction_ctx = InteractionContext(task_id, event_queue)
-            param_name = skill_def.interaction_param or "ctx"
-            params[param_name] = interaction_ctx
+        if skill_def.needs_auth:
+            param_name = skill_def.auth_param or "auth"
+            params[param_name] = metadata.get("auth_result")
 
         # Call the handler
         handler = skill_def.handler
@@ -211,8 +210,8 @@ class LiteAgentExecutor(AgentExecutor):
 
             # Skip special context types
             from .tasks import TaskContext as _TaskContext
-            from .human_loop import InteractionContext as _InteractionContext
-            if _is_or_subclass(param_type, _TaskContext) or _is_or_subclass(param_type, _InteractionContext):
+            from .auth import AuthResult as _AuthResult
+            if _is_or_subclass(param_type, _TaskContext) or _is_or_subclass(param_type, _AuthResult):
                 continue
 
             # Convert FilePart
@@ -345,7 +344,7 @@ class LiteAgentExecutor(AgentExecutor):
         if asyncio.iscoroutinefunction(handler):
             return await handler(*args, **kwargs)
         else:
-            loop = asyncio.get_event_loop()
+            loop = asyncio.get_running_loop()
             return await loop.run_in_executor(
                 None,
                 lambda: handler(*args, **kwargs)

a2a_lite/streaming.py

@@ -58,32 +58,3 @@ async def stream_generator(
             await event_queue.enqueue_event(new_agent_text_message(text))
 
 
-class StreamingResponse:
-    """
-    Helper class for building streaming responses.
-
-    Example:
-        @agent.skill("count")
-        async def count(n: int):
-            stream = StreamingResponse()
-            for i in range(n):
-                stream.write(f"Count: {i}")
-            return stream
-    """
-
-    def __init__(self):
-        self._chunks: list[str] = []
-
-    def write(self, chunk: str) -> None:
-        """Add a chunk to the stream."""
-        self._chunks.append(chunk)
-
-    def __iter__(self):
-        return iter(self._chunks)
-
-    def __aiter__(self):
-        return self._async_iter()
-
-    async def _async_iter(self):
-        for chunk in self._chunks:
-            yield chunk

a2a_lite/testing.py

@@ -214,7 +214,16 @@ class AgentTestClient:
                 result = await gen
                 results.append(result)
 
-        asyncio.run(run_handler())
+        # Handle both sync and async calling contexts
+        try:
+            asyncio.get_running_loop()
+            # Already in an async context — run in a separate thread
+            import concurrent.futures
+            with concurrent.futures.ThreadPoolExecutor(1) as pool:
+                pool.submit(asyncio.run, run_handler()).result()
+        except RuntimeError:
+            # No running loop — safe to use asyncio.run()
+            asyncio.run(run_handler())
         return results
 
 

a2a_lite/utils.py

@@ -1,6 +1,7 @@
 """
 Helper functions for A2A Lite.
 """
+import typing
 from typing import Any, Dict, Type, get_origin, get_args, Union
 import inspect
 
@@ -103,7 +104,10 @@ def extract_function_schemas(func) -> tuple[Dict[str, Any], Dict[str, Any]]:
         Tuple of (input_schema, output_schema)
     """
     sig = inspect.signature(func)
-    hints = getattr(func, '__annotations__', {})
+    try:
+        hints = typing.get_type_hints(func)
+    except Exception:
+        hints = getattr(func, '__annotations__', {})
 
     # Build input schema from parameters
     properties = {}