github-agent 0.2.7__tar.gz → 0.2.8__tar.gz

{github_agent-0.2.7 → github_agent-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: github-agent
-Version: 0.2.7
+Version: 0.2.8
 Summary: GitHub Agent for MCP
 Author-email: Audel Rouhi <knucklessg1@gmail.com>
 License: MIT
@@ -43,7 +43,7 @@ Dynamic: license-file
 ![PyPI - Wheel](https://img.shields.io/pypi/wheel/github-agent)
 ![PyPI - Implementation](https://img.shields.io/pypi/implementation/github-agent)
 
-*Version: 0.2.7*
+*Version: 0.2.8*
 
 ## Overview
 

{github_agent-0.2.7 → github_agent-0.2.8}/README.md

@@ -21,7 +21,7 @@
 ![PyPI - Wheel](https://img.shields.io/pypi/wheel/github-agent)
 ![PyPI - Implementation](https://img.shields.io/pypi/implementation/github-agent)
 
-*Version: 0.2.7*
+*Version: 0.2.8*
 
 ## Overview
 

{github_agent-0.2.7 → github_agent-0.2.8}/github_agent/github_agent.py

@@ -39,7 +39,7 @@ from pydantic import ValidationError
 from pydantic_ai.ui import SSE_CONTENT_TYPE
 from pydantic_ai.ui.ag_ui import AGUIAdapter
 
-__version__ = "0.2.7"
+__version__ = "0.2.8"
 
 logging.basicConfig(
     level=logging.INFO,
@@ -379,13 +379,39 @@ def create_agent(
             else:
                 pass
 
+        # Collect tool names for logging
+        all_tool_names = []
+        for ts in tag_toolsets:
+            try:
+                # Unwrap FilteredToolset
+                current_ts = ts
+                while hasattr(current_ts, "wrapped"):
+                    current_ts = current_ts.wrapped
+
+                # Check for .tools (e.g. SkillsToolset)
+                if hasattr(current_ts, "tools") and isinstance(current_ts.tools, dict):
+                    all_tool_names.extend(current_ts.tools.keys())
+                # Check for ._tools (some implementations might use private attr)
+                elif hasattr(current_ts, "_tools") and isinstance(
+                    current_ts._tools, dict
+                ):
+                    all_tool_names.extend(current_ts._tools.keys())
+                else:
+                    # Fallback for MCP or others where tools are not available sync
+                    all_tool_names.append(f"<{type(current_ts).__name__}>")
+            except Exception as e:
+                logger.info(f"Unable to retrieve toolset: {e}")
+                pass
+
+        tool_list_str = ", ".join(all_tool_names)
+        logger.info(f"Available tools for {agent_name} ({tag}): {tool_list_str}")
         agent = Agent(
-            name=agent_name,
-            system_prompt=system_prompt,
             model=model,
-            model_settings=settings,
+            system_prompt=system_prompt,
+            name=agent_name,
             toolsets=tag_toolsets,
             tool_timeout=DEFAULT_TOOL_TIMEOUT,
+            model_settings=settings,
         )
         child_agents[tag] = agent
 
@@ -400,171 +426,267 @@ def create_agent(
     @supervisor.tool
     async def assign_task_to_context_agent(ctx: RunContext[Any], task: str) -> str:
         """Assign a task related to user context and general GitHub status to the Context Agent."""
-        return (
-            await child_agents["person"].run(task, usage=ctx.usage, deps=ctx.deps)
-        ).output
+        try:
+            return (
+                await child_agents["person"].run(task, usage=ctx.usage, deps=ctx.deps)
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Context Agent: {e}")
+            return f"Error executing task for Context Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_actions_agent(ctx: RunContext[Any], task: str) -> str:
         """Assign a task related to GitHub Actions and Workflows to the Actions Agent."""
-        return (
-            await child_agents["workflow"].run(task, usage=ctx.usage, deps=ctx.deps)
-        ).output
+        try:
+            return (
+                await child_agents["workflow"].run(task, usage=ctx.usage, deps=ctx.deps)
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Actions Agent: {e}")
+            return f"Error executing task for Actions Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_code_security_agent(
         ctx: RunContext[Any], task: str
     ) -> str:
         """Assign a task related to code security and scanning to the Code Security Agent."""
-        return (
-            await child_agents["codescan"].run(task, usage=ctx.usage, deps=ctx.deps)
-        ).output
+        try:
+            return (
+                await child_agents["codescan"].run(task, usage=ctx.usage, deps=ctx.deps)
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Code Security Agent: {e}")
+            return f"Error executing task for Code Security Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_dependabot_agent(ctx: RunContext[Any], task: str) -> str:
         """Assign a task related to Dependabot to the Dependabot Agent."""
-        return (
-            await child_agents["dependabot"].run(task, usage=ctx.usage, deps=ctx.deps)
-        ).output
+        try:
+            return (
+                await child_agents["dependabot"].run(
+                    task, usage=ctx.usage, deps=ctx.deps
+                )
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Dependabot Agent: {e}")
+            return f"Error executing task for Dependabot Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_discussions_agent(ctx: RunContext[Any], task: str) -> str:
         """Assign a task related to GitHub Discussions to the Discussions Agent."""
-        return (
-            await child_agents["comment-discussion"].run(
-                task, usage=ctx.usage, deps=ctx.deps
-            )
-        ).output
+        try:
+            return (
+                await child_agents["comment-discussion"].run(
+                    task, usage=ctx.usage, deps=ctx.deps
+                )
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Discussions Agent: {e}")
+            return f"Error executing task for Discussions Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_gists_agent(ctx: RunContext[Any], task: str) -> str:
         """Assign a task related to Gists to the Gists Agent."""
-        return (
-            await child_agents["logo-gist"].run(task, usage=ctx.usage, deps=ctx.deps)
-        ).output
+        try:
+            return (
+                await child_agents["logo-gist"].run(
+                    task, usage=ctx.usage, deps=ctx.deps
+                )
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Gists Agent: {e}")
+            return f"Error executing task for Gists Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_git_agent(ctx: RunContext[Any], task: str) -> str:
         """Assign a task related to low-level Git operations (refs, blobs) to the Git Agent."""
-        return (
-            await child_agents["git-branch"].run(task, usage=ctx.usage, deps=ctx.deps)
-        ).output
+        try:
+            return (
+                await child_agents["git-branch"].run(
+                    task, usage=ctx.usage, deps=ctx.deps
+                )
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Git Agent: {e}")
+            return f"Error executing task for Git Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_issues_agent(ctx: RunContext[Any], task: str) -> str:
         """Assign a task related to Issues (create, list, comment) to the Issues Agent."""
-        return (
-            await child_agents["issue-opened"].run(task, usage=ctx.usage, deps=ctx.deps)
-        ).output
+        try:
+            return (
+                await child_agents["issue-opened"].run(
+                    task, usage=ctx.usage, deps=ctx.deps
+                )
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Issues Agent: {e}")
+            return f"Error executing task for Issues Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_labels_agent(ctx: RunContext[Any], task: str) -> str:
         """Assign a task related to Labels to the Labels Agent."""
-        return (
-            await child_agents["tag"].run(task, usage=ctx.usage, deps=ctx.deps)
-        ).output
+        try:
+            return (
+                await child_agents["tag"].run(task, usage=ctx.usage, deps=ctx.deps)
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Labels Agent: {e}")
+            return f"Error executing task for Labels Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_notifications_agent(
         ctx: RunContext[Any], task: str
     ) -> str:
         """Assign a task related to Notifications to the Notifications Agent."""
-        return (
-            await child_agents["bell"].run(task, usage=ctx.usage, deps=ctx.deps)
-        ).output
+        try:
+            return (
+                await child_agents["bell"].run(task, usage=ctx.usage, deps=ctx.deps)
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Notifications Agent: {e}")
+            return f"Error executing task for Notifications Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_organizations_agent(
         ctx: RunContext[Any], task: str
     ) -> str:
         """Assign a task related to Organizations to the Organizations Agent."""
-        return (
-            await child_agents["organization"].run(task, usage=ctx.usage, deps=ctx.deps)
-        ).output
+        try:
+            return (
+                await child_agents["organization"].run(
+                    task, usage=ctx.usage, deps=ctx.deps
+                )
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Organizations Agent: {e}")
+            return f"Error executing task for Organizations Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_projects_agent(ctx: RunContext[Any], task: str) -> str:
         """Assign a task related to GitHub Projects to the Projects Agent."""
-        return (
-            await child_agents["project"].run(task, usage=ctx.usage, deps=ctx.deps)
-        ).output
+        try:
+            return (
+                await child_agents["project"].run(task, usage=ctx.usage, deps=ctx.deps)
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Projects Agent: {e}")
+            return f"Error executing task for Projects Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_pull_requests_agent(
         ctx: RunContext[Any], task: str
     ) -> str:
         """Assign a task related to Pull Requests to the Pull Requests Agent."""
-        return (
-            await child_agents["git-pull-request"].run(
-                task, usage=ctx.usage, deps=ctx.deps
-            )
-        ).output
+        try:
+            return (
+                await child_agents["git-pull-request"].run(
+                    task, usage=ctx.usage, deps=ctx.deps
+                )
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Pull Requests Agent: {e}")
+            return f"Error executing task for Pull Requests Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_repos_agent(ctx: RunContext[Any], task: str) -> str:
         """Assign a task related to Repositories (list, settings, delete) to the Repositories Agent."""
-        return (
-            await child_agents["repo"].run(task, usage=ctx.usage, deps=ctx.deps)
-        ).output
+        try:
+            return (
+                await child_agents["repo"].run(task, usage=ctx.usage, deps=ctx.deps)
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Repositories Agent: {e}")
+            return f"Error executing task for Repositories Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_secret_protection_agent(
         ctx: RunContext[Any], task: str
     ) -> str:
         """Assign a task related to Secret Protection to the Secret Protection Agent."""
-        return (
-            await child_agents["shield-lock"].run(task, usage=ctx.usage, deps=ctx.deps)
-        ).output
+        try:
+            return (
+                await child_agents["shield-lock"].run(
+                    task, usage=ctx.usage, deps=ctx.deps
+                )
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Secret Protection Agent: {e}")
+            return f"Error executing task for Secret Protection Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_security_advisories_agent(
         ctx: RunContext[Any], task: str
     ) -> str:
         """Assign a task related to Security Advisories to the Security Advisories Agent."""
-        return (
-            await child_agents["shield"].run(task, usage=ctx.usage, deps=ctx.deps)
-        ).output
+        try:
+            return (
+                await child_agents["shield"].run(task, usage=ctx.usage, deps=ctx.deps)
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Security Advisories Agent: {e}")
+            return f"Error executing task for Security Advisories Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_stargazers_agent(ctx: RunContext[Any], task: str) -> str:
         """Assign a task related to Stargazers to the Stargazers Agent."""
-        return (
-            await child_agents["star"].run(task, usage=ctx.usage, deps=ctx.deps)
-        ).output
+        try:
+            return (
+                await child_agents["star"].run(task, usage=ctx.usage, deps=ctx.deps)
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Stargazers Agent: {e}")
+            return f"Error executing task for Stargazers Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_users_agent(ctx: RunContext[Any], task: str) -> str:
         """Assign a task related to Users to the Users Agent."""
-        return (
-            await child_agents["people"].run(task, usage=ctx.usage, deps=ctx.deps)
-        ).output
+        try:
+            return (
+                await child_agents["people"].run(task, usage=ctx.usage, deps=ctx.deps)
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Users Agent: {e}")
+            return f"Error executing task for Users Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_copilot_agent(ctx: RunContext[Any], task: str) -> str:
         """Assign a task related to GitHub Copilot coding tasks to the Copilot Agent."""
-        return (
-            await child_agents["copilot"].run(task, usage=ctx.usage, deps=ctx.deps)
-        ).output
+        try:
+            return (
+                await child_agents["copilot"].run(task, usage=ctx.usage, deps=ctx.deps)
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Copilot Agent: {e}")
+            return f"Error executing task for Copilot Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_copilot_spaces_agent(
         ctx: RunContext[Any], task: str
     ) -> str:
         """Assign a task related to Copilot Spaces to the Copilot Spaces Agent."""
-        return (
-            await child_agents["copilot_spaces"].run(
-                task, usage=ctx.usage, deps=ctx.deps
-            )
-        ).output
+        try:
+            return (
+                await child_agents["copilot_spaces"].run(
+                    task, usage=ctx.usage, deps=ctx.deps
+                )
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Copilot Spaces Agent: {e}")
+            return f"Error executing task for Copilot Spaces Agent: {e}"
 
     @supervisor.tool
     async def assign_task_to_support_docs_agent(ctx: RunContext[Any], task: str) -> str:
         """Assign a task to search GitHub Support Docs to the Support Docs Agent."""
-        return (
-            await child_agents["github_support_docs_search"].run(
-                task, usage=ctx.usage, deps=ctx.deps
-            )
-        ).output
+        try:
+            return (
+                await child_agents["github_support_docs_search"].run(
+                    task, usage=ctx.usage, deps=ctx.deps
+                )
+            ).output
+        except Exception as e:
+            logger.exception(f"Error in Support Docs Agent: {e}")
+            return f"Error executing task for Support Docs Agent: {e}"
 
     return supervisor
 
@@ -600,7 +722,6 @@ def create_agent_server(
         mcp_config=mcp_config,
         skills_directory=skills_directory,
         ssl_verify=ssl_verify,
-        timeout=DEFAULT_TIMEOUT,
     )
 
     if skills_directory and os.path.exists(skills_directory):

{github_agent-0.2.7 → github_agent-0.2.8}/github_agent.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: github-agent
-Version: 0.2.7
+Version: 0.2.8
 Summary: GitHub Agent for MCP
 Author-email: Audel Rouhi <knucklessg1@gmail.com>
 License: MIT
@@ -43,7 +43,7 @@ Dynamic: license-file
 ![PyPI - Wheel](https://img.shields.io/pypi/wheel/github-agent)
 ![PyPI - Implementation](https://img.shields.io/pypi/implementation/github-agent)
 
-*Version: 0.2.7*
+*Version: 0.2.8*
 
 ## Overview
 

{github_agent-0.2.7 → github_agent-0.2.8}/github_agent.egg-info/SOURCES.txt

@@ -9,4 +9,5 @@ github_agent.egg-info/SOURCES.txt
 github_agent.egg-info/dependency_links.txt
 github_agent.egg-info/entry_points.txt
 github_agent.egg-info/requires.txt
-github_agent.egg-info/top_level.txt
+github_agent.egg-info/top_level.txt
+scripts/validate_a2a_agent.py

{github_agent-0.2.7 → github_agent-0.2.8}/github_agent.egg-info/top_level.txt

@@ -1,2 +1,3 @@
 dist
 github_agent
+scripts

{github_agent-0.2.7 → github_agent-0.2.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "github-agent"
-version = "0.2.7"
+version = "0.2.8"
 readme = "README.md"
 description = "GitHub Agent for MCP"
 requires-python = ">=3.10"

github_agent-0.2.8/scripts/validate_a2a_agent.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+import asyncio
+import httpx
+import json
+import uuid
+
+A2A_URL = "http://audio-transcriber-agent.arpa/a2a/"
+
+
+async def main():
+    print(f"Validating A2A Agent at {A2A_URL}...")
+
+    questions = [
+        "What tools do you have available?",
+    ]
+
+    async with httpx.AsyncClient(timeout=10000.0) as client:
+
+        for q in questions:
+            print(f"\n\n\nUser: {q}")
+            print("--- Sending Request ---")
+
+            payload = {
+                "jsonrpc": "2.0",
+                "method": "message/send",
+                "params": {
+                    "message": {
+                        "kind": "message",
+                        "role": "user",
+                        "parts": [{"kind": "text", "text": q}],
+                        "messageId": str(uuid.uuid4()),
+                    }
+                },
+                "id": 1,
+            }
+
+            try:
+                url = A2A_URL
+                print(f"Trying POST {url} with JSON-RPC (message/send)...")
+                resp = await client.post(
+                    url, json=payload, headers={"Content-Type": "application/json"}
+                )
+
+                print(f"Status Code: {resp.status_code}")
+                if resp.status_code == 200:
+                    try:
+                        data = resp.json()
+                        print(f"Response (JSON):\n{json.dumps(data, indent=2)}")
+
+                        if "result" in data and "id" in data["result"]:
+                            task_id = data["result"]["id"]
+                            print(
+                                f"\nTask Submitted with ID: {task_id}. Polling for result..."
+                            )
+
+                            while True:
+                                await asyncio.sleep(2)
+                                poll_payload = {
+                                    "jsonrpc": "2.0",
+                                    "method": "tasks/get",
+                                    "params": {"id": task_id},
+                                    "id": 2,
+                                }
+                                poll_resp = await client.post(
+                                    url,
+                                    json=poll_payload,
+                                    headers={"Content-Type": "application/json"},
+                                )
+                                if poll_resp.status_code == 200:
+                                    poll_data = poll_resp.json()
+                                    if "result" in poll_data:
+                                        state = poll_data["result"]["status"]["state"]
+                                        print(f"Task State: {state}")
+                                        if state not in [
+                                            "submitted",
+                                            "running",
+                                            "working",
+                                        ]:
+                                            print(
+                                                f"\nTask Finished with state: {state}"
+                                            )
+
+                                            if "history" in poll_data["result"]:
+                                                history = poll_data["result"]["history"]
+                                                if history:
+                                                    last_msg = None
+                                                    for msg in reversed(history):
+                                                        if msg.get("role") != "user":
+                                                            last_msg = msg
+                                                            break
+
+                                                    if last_msg and "parts" in last_msg:
+                                                        print(
+                                                            "\n--- Agent Response ---"
+                                                        )
+                                                        for part in last_msg["parts"]:
+                                                            if "text" in part:
+                                                                print(part["text"])
+                                                            elif "content" in part:
+                                                                print(part["content"])
+                                                    elif last_msg:
+                                                        print(
+                                                            f"Final Message (No parts): {last_msg}"
+                                                        )
+                                                    else:
+                                                        print(
+                                                            "\n--- No Agent Response Found in History ---"
+                                                        )
+
+                                            print(
+                                                f"Full Result Debug:\n{json.dumps(poll_data, indent=2)}"
+                                            )
+                                            break
+                                    else:
+                                        print("Starting polling error key check...")
+                                        if "error" in poll_data:
+                                            print(
+                                                f"Polling Error: {poll_data['error']}"
+                                            )
+                                        break
+                                else:
+                                    print(f"Polling Failed: {poll_resp.status_code}")
+                                    print(f"Polling Error Details: {poll_resp.text}")
+                                    break
+
+                        if "error" in data:
+                            print(f"JSON-RPC Error: {data['error']}")
+                    except json.JSONDecodeError:
+                        print(f"Response (Text):\n{resp.text}")
+                else:
+                    print(f"Error: {resp.status_code}")
+                    print(resp.text)
+
+            except httpx.RequestError as e:
+                print(f"Connection failed to {url}: {e}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())