Merge branch 'main' into feat/role-flag

Author: kausmeows

cookbook/tools/mcp/gibsonai.py

@@ -43,33 +43,40 @@
 from agno.tools.mcp import MCPTools
 
 
-async def run_gibsonai_agent(message: str) -> None:
+async def run_gibsonai_agent(message: str):
     """Run the GibsonAI agent with the given message."""
-    async with MCPTools(
+    mcp_tools = MCPTools(
         "uvx --from gibson-cli@latest gibson mcp run",
         timeout_seconds=300,  # Extended timeout for GibsonAI operations
-    ) as mcp_tools:
-        agent = Agent(
-            name="GibsonAIAgent",
-            model=OpenAIChat(id="gpt-4o"),
-            tools=[mcp_tools],
-            description="Agent for managing database projects and schemas",
-            instructions=dedent("""\
-                You are a GibsonAI database assistant. Help users manage their database projects and schemas.
-
-                Your capabilities include:
-                - Creating new GibsonAI projects
-                - Managing database schemas (tables, columns, relationships)
-                - Deploying schema changes to hosted databases
-                - Querying database schemas and data
-                - Providing insights about database structure and best practices
-            """),
-            markdown=True,
-            show_tool_calls=True,
-        )
+    )
+
+    # Connect to the MCP server
+    await mcp_tools.connect()
+
+    agent = Agent(
+        name="GibsonAIAgent",
+        model=OpenAIChat(id="gpt-4o"),
+        tools=[mcp_tools],
+        description="Agent for managing database projects and schemas",
+        instructions=dedent("""\
+            You are a GibsonAI database assistant. Help users manage their database projects and schemas.
+
+            Your capabilities include:
+            - Creating new GibsonAI projects
+            - Managing database schemas (tables, columns, relationships)
+            - Deploying schema changes to hosted databases
+            - Querying database schemas and data
+            - Providing insights about database structure and best practices
+        """),
+        markdown=True,
+        show_tool_calls=True,
+    )
+
+    # Run the agent
+    await agent.aprint_response(message, stream=True)
 
-        # Run the agent
-        await agent.aprint_response(message, stream=True)
+    # Close the MCP connection
+    await mcp_tools.close()
 
 
 # Example usage

libs/agno/agno/tools/github.py

@@ -458,35 +458,71 @@ def create_issue(self, repo_name: str, title: str, body: Optional[str] = NotSet)
             logger.error(f"Error creating issue: {e}")
             return json.dumps({"error": str(e)})
 
-    def list_issues(self, repo_name: str, state: str = "open", limit: int = 20) -> str:
-        """List issues for a repository.
+    def list_issues(self, repo_name: str, state: str = "open", page: int = 1, per_page: int = 20) -> str:
+        """List issues for a repository with pagination.
 
         Args:
             repo_name (str): The full name of the repository (e.g., 'owner/repo').
             state (str, optional): The state of issues to list ('open', 'closed', 'all'). Defaults to 'open'.
-            limit (int, optional): The maximum number of issues to return. Defaults to 20.
+            page (int, optional): Page number of results to return, counting from 1. Defaults to 1.
+            per_page (int, optional): Number of results per page. Defaults to 20.
         Returns:
-            A JSON-formatted string containing a list of issues.
+            A JSON-formatted string containing a list of issues with pagination metadata.
         """
-        log_debug(f"Listing issues for repository: {repo_name} with state: {state}")
+        log_debug(f"Listing issues for repository: {repo_name} with state: {state}, page: {page}, per_page: {per_page}")
         try:
             repo = self.g.get_repo(repo_name)
+            
             issues = repo.get_issues(state=state)
+
             # Filter out pull requests after fetching issues
-            logger.info(f"Issues: {issues}")
-            filtered_issues = [issue for issue in issues if not issue.pull_request]
+            total_issues = 0
+            all_issues = []
+            for issue in issues:
+                if not issue.pull_request:
+                    all_issues.append(issue)
+                    total_issues += 1
+            
+            # Calculate pagination metadata
+            total_pages = (total_issues + per_page - 1) // per_page
+            
+            # Validate page number
+            if page < 1:
+                page = 1
+            elif page > total_pages and total_pages > 0:
+                page = total_pages
+            
+            # Get the specified page of results
             issue_list = []
-            for issue in filtered_issues[:limit]:
-                issue_info = {
-                    "number": issue.number,
-                    "title": issue.title,
-                    "user": issue.user.login,
-                    "created_at": issue.created_at.isoformat(),
-                    "state": issue.state,
-                    "url": issue.html_url,
-                }
-                issue_list.append(issue_info)
-            return json.dumps(issue_list, indent=2)
+            page_start = (page - 1) * per_page
+            page_end = page_start + per_page
+            
+            for i in range(page_start, min(page_end, total_issues)):
+                if i < len(all_issues):
+                    issue = all_issues[i]
+                    issue_info = {
+                        "number": issue.number,
+                        "title": issue.title,
+                        "user": issue.user.login,
+                        "created_at": issue.created_at.isoformat(),
+                        "state": issue.state,
+                        "url": issue.html_url,
+                    }
+                    issue_list.append(issue_info)
+            
+            meta = {
+                "current_page": page,
+                "per_page": per_page,
+                "total_items": total_issues,
+                "total_pages": total_pages
+            }
+            
+            response = {
+                "data": issue_list,
+                "meta": meta
+            }
+            
+            return json.dumps(response, indent=2)
         except GithubException as e:
             logger.error(f"Error listing issues: {e}")
             return json.dumps({"error": str(e)})

libs/agno/tests/unit/tools/test_github.py

@@ -170,19 +170,29 @@ def test_get_pull_request_with_details(mock_github):
     result = github_tools.list_issues("test-org/test-repo")
     result_data = json.loads(result)
 
-    assert len(result_data) == 2
-    assert result_data[0]["number"] == 1
-    assert result_data[0]["state"] == "open"
-    assert result_data[1]["number"] == 2
-    assert result_data[1]["state"] == "closed"
+    assert "data" in result_data
+    assert "meta" in result_data
+    assert len(result_data["data"]) == 2
+    assert result_data["data"][0]["number"] == 1
+    assert result_data["data"][0]["state"] == "open"
+    assert result_data["data"][1]["number"] == 2
+    assert result_data["data"][1]["state"] == "closed"
+    
+    # Check pagination metadata
+    assert result_data["meta"]["current_page"] == 1
+    assert result_data["meta"]["per_page"] == 20
+    assert result_data["meta"]["total_items"] == 2
+    assert result_data["meta"]["total_pages"] == 1
 
     # Test listing only open issues
     mock_repo.get_issues.return_value = [mock_issue1]
     result = github_tools.list_issues("test-org/test-repo", state="open")
     result_data = json.loads(result)
 
-    assert len(result_data) == 1
-    assert result_data[0]["state"] == "open"
+    assert "data" in result_data
+    assert len(result_data["data"]) == 1
+    assert result_data["data"][0]["state"] == "open"
+    assert result_data["meta"]["total_items"] == 1
 
 
 def test_create_issue(mock_github):