a2a-lite 0.2.2__py3-none-any.whl → 0.2.4__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.2"
+__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,14 +153,11 @@ 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:
@@ -190,9 +171,6 @@ 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
@@ -215,10 +193,8 @@ 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,
             )
 
@@ -264,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 = []
@@ -291,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,
@@ -315,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.
@@ -326,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
@@ -362,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:
@@ -375,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:
@@ -405,17 +360,6 @@ class Agent:
         if self._on_startup:
             asyncio.run(_run_startup())
 
-        # 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}[/]")
-
         # Production mode warning
         if self.production:
             url_str = self.url or f"http://{display_host}:{port}"
@@ -431,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,
@@ -459,10 +401,6 @@ class Agent:
             if self._on_shutdown:
                 asyncio.run(_run_shutdown())
 
-            # Unregister discovery
-            if self._discovery:
-                self._discovery.unregister()
-
     async def call_remote(
         self,
         agent_url: str,

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.2",
+    "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,10 +17,8 @@ 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]:
@@ -32,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

@@ -168,13 +168,6 @@ 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")
@@ -217,9 +210,8 @@ class LiteAgentExecutor(AgentExecutor):
 
             # Skip special context types
             from .tasks import TaskContext as _TaskContext
-            from .human_loop import InteractionContext as _InteractionContext
             from .auth import AuthResult as _AuthResult
-            if _is_or_subclass(param_type, _TaskContext) or _is_or_subclass(param_type, _InteractionContext) or _is_or_subclass(param_type, _AuthResult):
+            if _is_or_subclass(param_type, _TaskContext) or _is_or_subclass(param_type, _AuthResult):
                 continue
 
             # Convert FilePart

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