agent0-sdk 1.4.1__py3-none-any.whl → 1.5.0b1__py3-none-any.whl

agent0_sdk/core/subgraph_client.py

@@ -67,6 +67,12 @@ class SubgraphClient:
                 logger.debug("Subgraph schema missing agentWallet fields; retrying query without them")
                 q2 = query.replace("agentWalletChainId", "").replace("agentWallet", "")
                 return _do_query(q2)
+            # Some deployments do not yet expose `hasOASF` on AgentRegistrationFile.
+            if (("has no field" in msg and "hasOASF" in msg) or ("Cannot query field" in msg and "hasOASF" in msg)) and (
+                "hasOASF" in query
+            ):
+                logger.debug("Subgraph schema missing hasOASF; retrying query without it")
+                return _do_query(query.replace("hasOASF", "oasfEndpoint"))
             raise
         except requests.exceptions.RequestException as e:
             raise ConnectionError(f"Failed to query subgraph: {e}")
@@ -167,6 +173,181 @@ class SubgraphClient:
         result = self.query(query)
         return result.get('agents', [])
 
+    # -------------------------------------------------------------------------
+    # V2 query helpers (variable-based where clauses; used by unified search)
+    # -------------------------------------------------------------------------
+
+    def get_agents_v2(
+        self,
+        where: Optional[Dict[str, Any]],
+        first: int,
+        skip: int,
+        order_by: str,
+        order_direction: str,
+    ) -> List[Dict[str, Any]]:
+        query = """
+        query SearchAgentsV2($where: Agent_filter, $first: Int!, $skip: Int!, $orderBy: Agent_orderBy!, $orderDirection: OrderDirection!) {
+            agents(where: $where, first: $first, skip: $skip, orderBy: $orderBy, orderDirection: $orderDirection) {
+                id
+                chainId
+                agentId
+                agentURI
+                agentURIType
+                owner
+                operators
+                agentWallet
+                totalFeedback
+                createdAt
+                updatedAt
+                lastActivity
+                registrationFile {
+                    id
+                    agentId
+                    name
+                    description
+                    image
+                    active
+                    x402Support
+                    supportedTrusts
+                    mcpEndpoint
+                    mcpVersion
+                    a2aEndpoint
+                    a2aVersion
+                    webEndpoint
+                    emailEndpoint
+                    hasOASF
+                    oasfSkills
+                    oasfDomains
+                    ens
+                    did
+                    mcpTools
+                    mcpPrompts
+                    mcpResources
+                    a2aSkills
+                    createdAt
+                }
+            }
+        }
+        """
+        variables = {
+            "where": where,
+            "first": first,
+            "skip": skip,
+            "orderBy": order_by,
+            "orderDirection": order_direction,
+        }
+        try:
+            data = self.query(query, variables)
+            return data.get("agents", [])
+        except ValueError as e:
+            # Compatibility: some deployments do not support AgentRegistrationFile.hasOASF in the *filter input*.
+            # Retry by translating registrationFile_.hasOASF => oasfEndpoint existence checks.
+            msg = str(e)
+            if where and "hasOASF" in msg and ("AgentRegistrationFile" in msg or "AgentRegistrationFile_filter" in msg):
+                def rewrite(node: Any) -> Any:
+                    if isinstance(node, list):
+                        return [rewrite(x) for x in node]
+                    if not isinstance(node, dict):
+                        return node
+                    out: Dict[str, Any] = {}
+                    for k, v in node.items():
+                        if k == "registrationFile_" and isinstance(v, dict):
+                            rf = dict(v)
+                            if "hasOASF" in rf:
+                                want = bool(rf.get("hasOASF"))
+                                rf.pop("hasOASF", None)
+                                if want:
+                                    rf["oasfEndpoint_not"] = None
+                                else:
+                                    rf["oasfEndpoint"] = None
+                            out[k] = rewrite(rf)
+                        else:
+                            out[k] = rewrite(v)
+                    return out
+
+                variables2 = dict(variables)
+                variables2["where"] = rewrite(where)
+                data2 = self.query(query, variables2)
+                return data2.get("agents", [])
+            raise
+
+    def query_agent_metadatas(self, where: Dict[str, Any], first: int, skip: int) -> List[Dict[str, Any]]:
+        query = """
+        query AgentMetadatas($where: AgentMetadata_filter, $first: Int!, $skip: Int!) {
+            agentMetadatas(where: $where, first: $first, skip: $skip) {
+                id
+                key
+                value
+                updatedAt
+                agent { id }
+            }
+        }
+        """
+        try:
+            data = self.query(query, {"where": where, "first": first, "skip": skip})
+            return data.get("agentMetadatas", [])
+        except ValueError as e:
+            # Hosted subgraph compatibility: some deployments expose AgentMetadata list as `agentMetadata_collection`.
+            msg = str(e)
+            if ("has no field" in msg and "agentMetadatas" in msg) or ("Cannot query field" in msg and "agentMetadatas" in msg):
+                query2 = """
+                query AgentMetadataCollection($where: AgentMetadata_filter, $first: Int!, $skip: Int!) {
+                    agentMetadata_collection(where: $where, first: $first, skip: $skip) {
+                        id
+                        key
+                        value
+                        updatedAt
+                        agent { id }
+                    }
+                }
+                """
+                data2 = self.query(query2, {"where": where, "first": first, "skip": skip})
+                return data2.get("agentMetadata_collection", [])
+            raise
+
+    def query_feedbacks_minimal(
+        self,
+        where: Dict[str, Any],
+        first: int,
+        skip: int,
+        order_by: str = "createdAt",
+        order_direction: str = "desc",
+    ) -> List[Dict[str, Any]]:
+        query = """
+        query Feedbacks($where: Feedback_filter, $first: Int!, $skip: Int!, $orderBy: Feedback_orderBy!, $orderDirection: OrderDirection!) {
+            feedbacks(where: $where, first: $first, skip: $skip, orderBy: $orderBy, orderDirection: $orderDirection) {
+                id
+                agent { id }
+                clientAddress
+                value
+                tag1
+                tag2
+                endpoint
+                isRevoked
+                createdAt
+                responses(first: 1) { id }
+            }
+        }
+        """
+        data = self.query(
+            query,
+            {"where": where, "first": first, "skip": skip, "orderBy": order_by, "orderDirection": order_direction},
+        )
+        return data.get("feedbacks", [])
+
+    def query_feedback_responses(self, where: Dict[str, Any], first: int, skip: int) -> List[Dict[str, Any]]:
+        query = """
+        query FeedbackResponses($where: FeedbackResponse_filter, $first: Int!, $skip: Int!) {
+            feedbackResponses(where: $where, first: $first, skip: $skip) {
+                id
+                feedback { id }
+                createdAt
+            }
+        }
+        """
+        data = self.query(query, {"where": where, "first": first, "skip": skip})
+        return data.get("feedbackResponses", [])
+
     def get_agent_by_id(self, agent_id: str, include_registration_file: bool = True) -> Optional[Dict[str, Any]]:
         """
         Get a specific agent by ID.
@@ -612,242 +793,4 @@ class SubgraphClient:
         result = self.query(query)
         return result.get('feedbacks', [])
     
-    def search_agents_by_reputation(
-        self,
-        agents: Optional[List[str]] = None,
-        tags: Optional[List[str]] = None,
-        reviewers: Optional[List[str]] = None,
-        capabilities: Optional[List[str]] = None,
-        skills: Optional[List[str]] = None,
-        tasks: Optional[List[str]] = None,
-        names: Optional[List[str]] = None,
-        minAverageValue: Optional[float] = None,
-        includeRevoked: bool = False,
-        first: int = 100,
-        skip: int = 0,
-        order_by: str = "createdAt",
-        order_direction: str = "desc",
-    ) -> List[Dict[str, Any]]:
-        """
-        Search agents filtered by reputation criteria.
-        
-        Args:
-            agents: List of agent IDs to filter by
-            tags: List of tags to filter feedback by
-            reviewers: List of reviewer addresses to filter feedback by
-            capabilities: List of capabilities to filter feedback by
-            skills: List of skills to filter feedback by
-            tasks: List of tasks to filter feedback by
-            minAverageValue: Minimum average value for included agents
-            includeRevoked: Whether to include revoked feedback in calculations
-            first: Number of results to return
-            skip: Number of results to skip
-            order_by: Field to order by
-            order_direction: Sort direction (asc/desc)
-            
-        Returns:
-            List of agents with averageValue field calculated from filtered feedback
-        """
-        # Build feedback filter
-        feedback_filters = []
-        
-        if not includeRevoked:
-            feedback_filters.append('isRevoked: false')
-        
-        if tags is not None and len(tags) > 0:
-            # Tags are now stored as human-readable strings in the subgraph
-            tag_filter = []
-            for tag in tags:
-                tag_filter.append(f'{{or: [{{tag1: "{tag}"}}, {{tag2: "{tag}"}}]}}')
-            feedback_filters.append(f'or: [{", ".join(tag_filter)}]')
-        
-        if reviewers is not None and len(reviewers) > 0:
-            reviewers_list = [f'"{addr}"' for addr in reviewers]
-            feedback_filters.append(f'clientAddress_in: [{", ".join(reviewers_list)}]')
-        
-        # Feedback file filters
-        feedback_file_filters = []
-        
-        if capabilities is not None and len(capabilities) > 0:
-            capabilities_list = [f'"{cap}"' for cap in capabilities]
-            feedback_file_filters.append(f'capability_in: [{", ".join(capabilities_list)}]')
-        
-        if skills is not None and len(skills) > 0:
-            skills_list = [f'"{skill}"' for skill in skills]
-            feedback_file_filters.append(f'skill_in: [{", ".join(skills_list)}]')
-        
-        if tasks is not None and len(tasks) > 0:
-            tasks_list = [f'"{task}"' for task in tasks]
-            feedback_file_filters.append(f'task_in: [{", ".join(tasks_list)}]')
-        
-        if names is not None and len(names) > 0:
-            names_list = [f'"{name}"' for name in names]
-            feedback_file_filters.append(f'name_in: [{", ".join(names_list)}]')
-        
-        if feedback_file_filters:
-            feedback_filters.append(f'feedbackFile_: {{ {", ".join(feedback_file_filters)} }}')
-        
-        # If we have feedback filters (tags, capabilities, skills, etc.), we need to first
-        # query feedback to get agent IDs, then query those agents
-        # Otherwise, query agents directly
-        if tags or capabilities or skills or tasks or names or reviewers:
-            # First, query feedback to get unique agent IDs that have matching feedback
-            feedback_where = f"{{ {', '.join(feedback_filters)} }}" if feedback_filters else "{}"
-            
-            feedback_query = f"""
-            {{
-                feedbacks(
-                    where: {feedback_where}
-                    first: 1000
-                    skip: 0
-                ) {{
-                    agent {{
-                        id
-                    }}
-                }}
-            }}
-            """
-            
-            try:
-                feedback_result = self.query(feedback_query)
-                feedbacks_data = feedback_result.get('feedbacks', [])
-                
-                # Extract unique agent IDs
-                agent_ids_set = set()
-                for fb in feedbacks_data:
-                    agent = fb.get('agent', {})
-                    agent_id = agent.get('id')
-                    if agent_id:
-                        agent_ids_set.add(agent_id)
-                
-                if not agent_ids_set:
-                    # No agents have matching feedback
-                    return []
-                
-                # Now query only those agents
-                agent_ids_list = list(agent_ids_set)
-                # Apply any agent filters if specified
-                if agents is not None and len(agents) > 0:
-                    agent_ids_list = [aid for aid in agent_ids_list if aid in agents]
-                    if not agent_ids_list:
-                        return []
-                
-                # Query agents (limit to first N based on pagination)
-                agent_ids_str = ', '.join([f'"{aid}"' for aid in agent_ids_list])
-                agent_where = f"where: {{ id_in: [{agent_ids_str}] }}"
-            except Exception as e:
-                logger.warning(f"Failed to query feedback for agent IDs: {e}")
-                return []
-        else:
-            # No feedback filters - query agents directly
-            # For reputation search, we want agents that have feedback
-            # Filter by totalFeedback > 0 to only get agents with feedback
-            agent_filters = ['totalFeedback_gt: 0']  # Only agents with feedback (BigInt comparison)
-            if agents is not None and len(agents) > 0:
-                agent_ids = [f'"{aid}"' for aid in agents]
-                agent_filters.append(f'id_in: [{", ".join(agent_ids)}]')
-            
-            agent_where = f"where: {{ {', '.join(agent_filters)} }}"
-        
-        # Build feedback where for agent query (to calculate scores)
-        feedback_where_for_agents = f"{{ {', '.join(feedback_filters)} }}" if feedback_filters else "{}"
-        
-        query = f"""
-        {{
-            agents(
-                {agent_where}
-                first: {first}
-                skip: {skip}
-                orderBy: {order_by}
-                orderDirection: {order_direction}
-            ) {{
-                id
-                chainId
-                agentId
-                agentURI
-                agentURIType
-                owner
-                operators
-                createdAt
-                updatedAt
-                totalFeedback
-                lastActivity
-                registrationFile {{
-                    id
-                    name
-                    description
-                    image
-                    active
-                    x402Support
-                    supportedTrusts
-                    mcpEndpoint
-                    mcpVersion
-                    a2aEndpoint
-                    a2aVersion
-                    ens
-                    did
-                    agentWallet
-                    agentWalletChainId
-                    mcpTools
-                    mcpPrompts
-                    mcpResources
-                    a2aSkills
-                    createdAt
-                }}
-                feedback(where: {feedback_where_for_agents}) {{
-                    value
-                    isRevoked
-                    feedbackFile {{
-                        capability
-                        skill
-                        task
-                        name
-                    }}
-                }}
-            }}
-        }}
-        """
-        
-        try:
-            result = self.query(query)
-            
-            # Check for GraphQL errors
-            if 'errors' in result:
-                logger.error(f"GraphQL errors in search_agents_by_reputation: {result['errors']}")
-                return []
-            
-            agents_result = result.get('agents', [])
-            
-            # Calculate average values
-            for agent in agents_result:
-                feedbacks = agent.get('feedback', [])
-                if feedbacks:
-                    values = [float(fb["value"]) for fb in feedbacks if fb.get("value") is not None]
-                    agent["averageValue"] = (sum(values) / len(values)) if values else None
-                else:
-                    agent["averageValue"] = None
-            
-            # Filter by minAverageValue
-            if minAverageValue is not None:
-                agents_result = [
-                    agent for agent in agents_result
-                    if agent.get("averageValue") is not None and agent["averageValue"] >= minAverageValue
-                ]
-            
-            # For reputation search, filter logic:
-            # - If specific agents were requested, return them even if averageValue is None
-            #   (the user explicitly asked for these agents, so return them)
-            # - If general search (no specific agents), only return agents with reputation data
-            if agents is None or len(agents) == 0:
-                # General search - only return agents with reputation
-                agents_result = [
-                    agent for agent in agents_result
-                    if agent.get("averageValue") is not None
-                ]
-            # else: specific agents requested - return all requested agents (even if averageValue is None)
-            
-            return agents_result
-            
-        except Exception as e:
-            logger.warning(f"Subgraph reputation search failed: {e}")
-            return []
+    # NOTE: `search_agents_by_reputation` was removed in favor of unified `SDK.searchAgents()` with `filters.feedback`.

{agent0_sdk-1.4.1.dist-info → agent0_sdk-1.5.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent0-sdk
-Version: 1.4.1
+Version: 1.5.0b1
 Summary: Python SDK for agent portability, discovery and trust based on ERC-8004
 Author-email: Agent0 Team <team@ag0.xyz>
 License: MIT License
@@ -104,6 +104,12 @@ Agent0 SDK enables you to:
 pip install agent0-sdk
 ```
 
+To install the **1.5.0 pre-release** explicitly:
+
+```bash
+pip install --pre agent0-sdk==1.5.0b1
+```
+
 ### Install from Source
 
 ```bash
@@ -122,7 +128,7 @@ import os
 
 # Initialize SDK with IPFS and subgraph
 sdk = SDK(
-    chainId=11155111,  # Ethereum Sepolia testnet
+    chainId=11155111,  # Ethereum Sepolia testnet (use 1 for Ethereum Mainnet)
     rpcUrl=os.getenv("RPC_URL"),
     signer=os.getenv("PRIVATE_KEY"),
     ipfs="pinata",  # Options: "pinata", "filecoinPin", "node"
@@ -198,11 +204,15 @@ print(f"Updated: {update.agentURI}")
 ```python
 # Search by name, capabilities, or attributes
 results = sdk.searchAgents(
-    name="AI",  # Substring search
-    mcpTools=["code_generation"],  # Specific MCP tools
-    a2aSkills=["python"],  # Specific A2A skills
-    active=True,  # Only active agents
-    x402support=True  # Payment support
+    filters={
+        "name": "AI",  # substring
+        "mcpTools": ["code_generation"],
+        "a2aSkills": ["python"],
+        "active": True,
+        "x402support": True,
+        "feedback": {"minValue": 80, "tag": "enterprise", "includeRevoked": False},
+    },
+    options={"pageSize": 20, "sort": ["updatedAt:desc"]},
 )
 
 for agent in results['items']:
@@ -364,7 +374,7 @@ Browse these files to find appropriate skill and domain slugs. For more informat
 
 ## 🚀 Coming Soon
 
-- More chains (currently Ethereum Sepolia only)
+- More chains (currently Ethereum Sepolia + Ethereum Mainnet)
 - Support for validations
 - Enhanced x402 payments
 - Semantic/Vectorial search

agent0_sdk-1.5.0b1.dist-info/RECORD

@@ -0,0 +1,22 @@
+agent0_sdk/__init__.py,sha256=XAcKn73_sk5qlTtmT4w_LDMRvwYjPWbn1qppyWh82r4,1190
+agent0_sdk/core/agent.py,sha256=P3AX7zm4G5qkWdTJcjOvR69cCyOovHefbRoKejj6QKY,48062
+agent0_sdk/core/contracts.py,sha256=EVxtxc5z6hI7p40Va5ibu0Pssmi6Y6UEG1_wfO7TZ_U,22942
+agent0_sdk/core/endpoint_crawler.py,sha256=QBkFc3tBSQqHj6PtSTZ5D3_HVB00KJZJdxE3uYpI9po,13611
+agent0_sdk/core/feedback_manager.py,sha256=gHCyBYK17Yc5HcxDcbhl_blXYqulYO-7oiEvoPQomms,42585
+agent0_sdk/core/indexer.py,sha256=pCVrgWXVVJJMAu_ABs-nweAK9rZ-DR2uMSA51T7KaPY,102199
+agent0_sdk/core/ipfs_client.py,sha256=17XXMpJgLWhcNUSkmduAZt409c8oJXlj9C_eTGVk-Io,14185
+agent0_sdk/core/models.py,sha256=ssgMPzCv7ykalF9je9KqFLD4ep_lAYU_P9E8L8fl0Lw,14451
+agent0_sdk/core/oasf_validator.py,sha256=ZOtYYzQd7cJj3eJegi7Ch5ydoapJEjaJSxMvwzKSp5o,2980
+agent0_sdk/core/sdk.py,sha256=JjBEpDvnoOSEkZcr9vPqjzaDCUcrJobY43o3oICgiRY,27632
+agent0_sdk/core/semantic_search_client.py,sha256=dMI9dT2MtgdlYE07ttPgOPV2yusdlD9C-DMHNEj7wrA,1837
+agent0_sdk/core/subgraph_client.py,sha256=VBHSdMKIr-DLRKu0bGQMBC_fdxI8SgNMqVLpPWYuQc0,27374
+agent0_sdk/core/transaction_handle.py,sha256=tKo6ny02m3eIeDGo0Wjikf-yUtl_8KYJy5YxFkPvyHo,1958
+agent0_sdk/core/value_encoding.py,sha256=NQUUvjTRAr5Tqj8t4HUGlfhak8VDmB8E5WMlfAqJwVk,3311
+agent0_sdk/core/web3_client.py,sha256=9w5ZgHILteCHSOisae3QluwuIsX3OD-VkoAc01koQWA,13786
+agent0_sdk/taxonomies/all_domains.json,sha256=buM8_6mpY8_AMbBIPzM-gtu14Tl30QDmhuQxxrlJU4c,74625
+agent0_sdk/taxonomies/all_skills.json,sha256=WVsutw3fqoj1jfDPru3CyWTr1kc1a5-EhBOWPfXnEi8,47483
+agent0_sdk-1.5.0b1.dist-info/licenses/LICENSE,sha256=rhZZbZm_Ovz4Oa9LNQ-ms8a1tA36wWh90ZkC0OR7WMw,1072
+agent0_sdk-1.5.0b1.dist-info/METADATA,sha256=-GtWe1NHrXnsAKDrEwM67K61yG-4Lr4hnRjkUJ_qoOU,15431
+agent0_sdk-1.5.0b1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+agent0_sdk-1.5.0b1.dist-info/top_level.txt,sha256=p4520WUKNfhU0lVWJgkrB_jdeUfvHSY3K18k4oYLNfI,11
+agent0_sdk-1.5.0b1.dist-info/RECORD,,

agent0_sdk-1.4.1.dist-info/RECORD

@@ -1,21 +0,0 @@
-agent0_sdk/__init__.py,sha256=dz1Rxuq5FoLGuA6F-6O8sopQ8WVVmWjYHLJGwVvrKsY,1102
-agent0_sdk/core/agent.py,sha256=P3AX7zm4G5qkWdTJcjOvR69cCyOovHefbRoKejj6QKY,48062
-agent0_sdk/core/contracts.py,sha256=5AAY0_GCOkw8FL49_dDpGF6TwFk1OCwzFe8Je0jb7Oc,22787
-agent0_sdk/core/endpoint_crawler.py,sha256=QBkFc3tBSQqHj6PtSTZ5D3_HVB00KJZJdxE3uYpI9po,13611
-agent0_sdk/core/feedback_manager.py,sha256=gHCyBYK17Yc5HcxDcbhl_blXYqulYO-7oiEvoPQomms,42585
-agent0_sdk/core/indexer.py,sha256=gz4DDQQcRbe1RQtFSgq4OZLLFwXHFIe4v2-CcpD077A,72661
-agent0_sdk/core/ipfs_client.py,sha256=17XXMpJgLWhcNUSkmduAZt409c8oJXlj9C_eTGVk-Io,14185
-agent0_sdk/core/models.py,sha256=kiCtRm_ORdBph-Ces0HStsY92jnevY5yCpITb0PZErw,12218
-agent0_sdk/core/oasf_validator.py,sha256=ZOtYYzQd7cJj3eJegi7Ch5ydoapJEjaJSxMvwzKSp5o,2980
-agent0_sdk/core/sdk.py,sha256=w1Q6oCrQoXnCd9fgFlz1rOM0P1JbLYWAB8gs1Upz4IU,39510
-agent0_sdk/core/subgraph_client.py,sha256=seEisw__r9nqQl1CgXa5DiUb6EvZ2GG7qS4wQPLILWo,29854
-agent0_sdk/core/transaction_handle.py,sha256=tKo6ny02m3eIeDGo0Wjikf-yUtl_8KYJy5YxFkPvyHo,1958
-agent0_sdk/core/value_encoding.py,sha256=NQUUvjTRAr5Tqj8t4HUGlfhak8VDmB8E5WMlfAqJwVk,3311
-agent0_sdk/core/web3_client.py,sha256=9w5ZgHILteCHSOisae3QluwuIsX3OD-VkoAc01koQWA,13786
-agent0_sdk/taxonomies/all_domains.json,sha256=buM8_6mpY8_AMbBIPzM-gtu14Tl30QDmhuQxxrlJU4c,74625
-agent0_sdk/taxonomies/all_skills.json,sha256=WVsutw3fqoj1jfDPru3CyWTr1kc1a5-EhBOWPfXnEi8,47483
-agent0_sdk-1.4.1.dist-info/licenses/LICENSE,sha256=rhZZbZm_Ovz4Oa9LNQ-ms8a1tA36wWh90ZkC0OR7WMw,1072
-agent0_sdk-1.4.1.dist-info/METADATA,sha256=hUaaBL4JaACaiDuJQIc4UPLklW1aygaH0bo-dY_zbDQ,15179
-agent0_sdk-1.4.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-agent0_sdk-1.4.1.dist-info/top_level.txt,sha256=p4520WUKNfhU0lVWJgkrB_jdeUfvHSY3K18k4oYLNfI,11
-agent0_sdk-1.4.1.dist-info/RECORD,,