agent0-sdk 1.4.2__py3-none-any.whl → 1.5.1b1__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.2.dist-info → agent0_sdk-1.5.1b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent0-sdk
-Version: 1.4.2
+Version: 1.5.1b1
 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.1 pre-release** explicitly:
+
+```bash
+pip install --pre agent0-sdk==1.5.1b1
+```
+
 ### Install from Source
 
 ```bash
@@ -198,14 +204,18 @@ 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={"sort": ["updatedAt:desc"]},
 )
 
-for agent in results['items']:
+for agent in results:
     print(f"{agent.name}: {agent.description}")
     print(f"  Tools: {agent.mcpTools}")
     print(f"  Skills: {agent.a2aSkills}")
@@ -355,6 +365,151 @@ The SDK includes complete OASF v0.8.0 taxonomy files:
 
 Browse these files to find appropriate skill and domain slugs. For more information, see the [OASF specification](https://github.com/agntcy/oasf) and [Release Notes v0.31](RELEASE_NOTES_0.31.md).
 
+## Unified Search Reference (Exhaustive)
+
+The unified search API is:
+
+```python
+results = sdk.searchAgents(filters: dict | SearchFilters | None = None, options: dict | SearchOptions | None = None)
+# results: list[AgentSummary]
+```
+
+### `FeedbackFilters` (used as `filters["feedback"]`)
+
+```python
+@dataclass
+class FeedbackFilters:
+    hasFeedback: Optional[bool] = None
+    hasNoFeedback: Optional[bool] = None
+    includeRevoked: Optional[bool] = None
+    minValue: Optional[float] = None
+    maxValue: Optional[float] = None
+    minCount: Optional[int] = None
+    maxCount: Optional[int] = None
+    fromReviewers: Optional[List[Address]] = None
+    endpoint: Optional[str] = None          # substring match
+    hasResponse: Optional[bool] = None
+    tag1: Optional[str] = None
+    tag2: Optional[str] = None
+    tag: Optional[str] = None               # matches tag1 OR tag2
+```
+
+| Field | Semantics |
+| --- | --- |
+| `hasFeedback` / `hasNoFeedback` | Filter by whether the agent has any feedback |
+| `includeRevoked` | Include revoked feedback entries in the pool used for filtering |
+| `minValue` / `maxValue` | Threshold on **average value** over feedback matching the other feedback constraints (inclusive) |
+| `minCount` / `maxCount` | Threshold on **count** over feedback matching the other feedback constraints (inclusive) |
+| `fromReviewers` | Only consider feedback from these reviewer wallets |
+| `endpoint` | Only consider feedback whose `endpoint` contains this substring |
+| `hasResponse` | Only consider feedback that has at least one response (if supported) |
+| `tag1` / `tag2` | Only consider feedback matching tag1/tag2 |
+| `tag` | Shorthand: match either tag1 OR tag2 |
+
+### `SearchFilters`
+
+```python
+DateLike = Union[datetime, str, int]
+
+@dataclass
+class SearchFilters:
+    chains: Optional[Union[List[ChainId], Literal["all"]]] = None
+    agentIds: Optional[List[AgentId]] = None
+
+    name: Optional[str] = None
+    description: Optional[str] = None
+
+    owners: Optional[List[Address]] = None
+    operators: Optional[List[Address]] = None
+
+    hasRegistrationFile: Optional[bool] = None
+    hasWeb: Optional[bool] = None
+    hasMCP: Optional[bool] = None
+    hasA2A: Optional[bool] = None
+    hasOASF: Optional[bool] = None
+    hasEndpoints: Optional[bool] = None
+
+    webContains: Optional[str] = None
+    mcpContains: Optional[str] = None
+    a2aContains: Optional[str] = None
+    ensContains: Optional[str] = None
+    didContains: Optional[str] = None
+
+    walletAddress: Optional[Address] = None
+
+    supportedTrust: Optional[List[str]] = None
+    a2aSkills: Optional[List[str]] = None
+    mcpTools: Optional[List[str]] = None
+    mcpPrompts: Optional[List[str]] = None
+    mcpResources: Optional[List[str]] = None
+    oasfSkills: Optional[List[str]] = None
+    oasfDomains: Optional[List[str]] = None
+
+    active: Optional[bool] = None
+    x402support: Optional[bool] = None
+
+    registeredAtFrom: Optional[DateLike] = None
+    registeredAtTo: Optional[DateLike] = None
+    updatedAtFrom: Optional[DateLike] = None
+    updatedAtTo: Optional[DateLike] = None
+
+    hasMetadataKey: Optional[str] = None
+    metadataValue: Optional[Dict[str, str]] = None  # { key, value }
+
+    keyword: Optional[str] = None
+    feedback: Optional[FeedbackFilters] = None
+```
+
+### `SearchOptions`
+
+```python
+@dataclass
+class SearchOptions:
+    sort: Optional[List[str]] = None
+    semanticMinScore: Optional[float] = None
+    semanticTopK: Optional[int] = None
+```
+
+### `AgentSummary` (returned items)
+
+```python
+@dataclass
+class AgentSummary:
+    chainId: ChainId
+    agentId: AgentId
+    name: str
+    image: Optional[URI]
+    description: str
+    owners: List[Address]
+    operators: List[Address]
+    # Endpoint strings (present when advertised; not booleans)
+    mcp: Optional[str] = None
+    a2a: Optional[str] = None
+    web: Optional[str] = None
+    email: Optional[str] = None
+    ens: Optional[str] = None
+    did: Optional[str] = None
+    walletAddress: Optional[Address] = None
+    supportedTrusts: List[str] = field(default_factory=list)
+    a2aSkills: List[str] = field(default_factory=list)
+    mcpTools: List[str] = field(default_factory=list)
+    mcpPrompts: List[str] = field(default_factory=list)
+    mcpResources: List[str] = field(default_factory=list)
+    oasfSkills: List[str] = field(default_factory=list)
+    oasfDomains: List[str] = field(default_factory=list)
+    active: bool = False
+    x402support: bool = False
+    createdAt: Optional[int] = None
+    updatedAt: Optional[int] = None
+    lastActivity: Optional[int] = None
+    agentURI: Optional[str] = None
+    agentURIType: Optional[str] = None
+    feedbackCount: Optional[int] = None
+    averageValue: Optional[float] = None
+    semanticScore: Optional[float] = None
+    extras: Dict[str, Any] = field(default_factory=dict)
+```
+
 ## Use Cases
 
 - **Building agent marketplaces** - Create platforms where developers can discover, evaluate, and integrate agents based on their capabilities and reputation
@@ -364,10 +519,9 @@ Browse these files to find appropriate skill and domain slugs. For more informat
 
 ## 🚀 Coming Soon
 
-- More chains (currently Ethereum Sepolia + Ethereum Mainnet)
+- More chains (currently Ethereum Mainnet + Ethereum Sepolia + Polygon Mainnet)
 - Support for validations
 - Enhanced x402 payments
-- Semantic/Vectorial search
 - Advanced reputation aggregation
 - Import/Export to centralized catalogues
 

agent0_sdk-1.5.1b1.dist-info/RECORD

@@ -0,0 +1,22 @@
+agent0_sdk/__init__.py,sha256=l-IYzlB87rfM6Rigthoasgc80HmQ-BHHbJENZU6St6I,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=rgQSxjNlEtBLN_bzQ1rnPL2kuaHCHM5vIEyw7Uitg3Q,42696
+agent0_sdk/core/indexer.py,sha256=apXiAA-kYEcRMv6s8NgiguwinPs3cKihLZ4B8jqaPAE,75122
+agent0_sdk/core/ipfs_client.py,sha256=17XXMpJgLWhcNUSkmduAZt409c8oJXlj9C_eTGVk-Io,14185
+agent0_sdk/core/models.py,sha256=xZc93KKzsgc1cm0yymN2lFaMFv6MuaUNS9tcxT6Lktg,14383
+agent0_sdk/core/oasf_validator.py,sha256=ZOtYYzQd7cJj3eJegi7Ch5ydoapJEjaJSxMvwzKSp5o,2980
+agent0_sdk/core/sdk.py,sha256=TKagv6AufrCWFmfOa79yODa6--PP4tt5G8UCXWS59N0,27484
+agent0_sdk/core/semantic_search_client.py,sha256=MrWMKmZ6qQhqKiIDiS2W5Aop4ak-YQ9VastIVlVzL0c,2013
+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.1b1.dist-info/licenses/LICENSE,sha256=rhZZbZm_Ovz4Oa9LNQ-ms8a1tA36wWh90ZkC0OR7WMw,1072
+agent0_sdk-1.5.1b1.dist-info/METADATA,sha256=srsv0FCyL6LWGo3zldnLEHVH-CQAXQ7lnAqSnRoIc_k,20216
+agent0_sdk-1.5.1b1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+agent0_sdk-1.5.1b1.dist-info/top_level.txt,sha256=p4520WUKNfhU0lVWJgkrB_jdeUfvHSY3K18k4oYLNfI,11
+agent0_sdk-1.5.1b1.dist-info/RECORD,,

agent0_sdk-1.4.2.dist-info/RECORD

@@ -1,21 +0,0 @@
-agent0_sdk/__init__.py,sha256=NUCdspMGo80UwULYUXXvd6rCtwlnj0qhEA7fa_nMb5M,1102
-agent0_sdk/core/agent.py,sha256=P3AX7zm4G5qkWdTJcjOvR69cCyOovHefbRoKejj6QKY,48062
-agent0_sdk/core/contracts.py,sha256=o2e_2w8YnPlf-VVVI4s7VE7p39uSjj2zJ0gVXyMbeOM,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.2.dist-info/licenses/LICENSE,sha256=rhZZbZm_Ovz4Oa9LNQ-ms8a1tA36wWh90ZkC0OR7WMw,1072
-agent0_sdk-1.4.2.dist-info/METADATA,sha256=D6o0O1JHNKDkLLo3tv4NOvsz5A7LAf2Zrw44rtuh5u8,15222
-agent0_sdk-1.4.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-agent0_sdk-1.4.2.dist-info/top_level.txt,sha256=p4520WUKNfhU0lVWJgkrB_jdeUfvHSY3K18k4oYLNfI,11
-agent0_sdk-1.4.2.dist-info/RECORD,,