agent0-sdk 1.0.1__py3-none-any.whl → 1.0.2__py3-none-any.whl

agent0_sdk/__init__.py

@@ -30,7 +30,7 @@ except ImportError:
     Agent = None
     _sdk_available = False
 
-__version__ = "1.0.1"
+__version__ = "1.0.2"
 __all__ = [
     "SDK",
     "Agent",

agent0_sdk/core/agent.py

@@ -327,7 +327,8 @@ class Agent:
         oasf_endpoint = Endpoint(
             type=EndpointType.OASF,
             value="https://github.com/agntcy/oasf/",
-            meta={"version": "v0.8.0", "skills": [], "domains": []}
+            # Version string follows ERC-8004 spec example ("0.8")
+            meta={"version": "0.8", "skills": [], "domains": []}
         )
         self.registration_file.endpoints.append(oasf_endpoint)
         return oasf_endpoint
@@ -529,14 +530,14 @@ class Agent:
             raise ValueError("Wallet address cannot be empty. Use a non-zero address.")
         
         # Validate address format
-        if not addr.startswith("0x") or len(addr) != 42:
-            raise ValueError(f"Invalid Ethereum address format: {addr}. Must be 42 characters starting with '0x'")
-        
-        # Validate hexadecimal characters
-        try:
-            int(addr[2:], 16)
-        except ValueError:
-            raise ValueError(f"Invalid hexadecimal characters in address: {addr}")
+            if not addr.startswith("0x") or len(addr) != 42:
+                raise ValueError(f"Invalid Ethereum address format: {addr}. Must be 42 characters starting with '0x'")
+            
+            # Validate hexadecimal characters
+            try:
+                int(addr[2:], 16)
+            except ValueError:
+                raise ValueError(f"Invalid hexadecimal characters in address: {addr}")
         
         # Determine chain ID to use (local bookkeeping)
         if chainId is None:

agent0_sdk/core/contracts.py

@@ -346,7 +346,8 @@ REPUTATION_REGISTRY_ABI = [
             {"indexed": True, "internalType": "address", "name": "clientAddress", "type": "address"},
             {"indexed": False, "internalType": "uint64", "name": "feedbackIndex", "type": "uint64"},
             {"indexed": False, "internalType": "uint8", "name": "score", "type": "uint8"},
-            {"indexed": True, "internalType": "string", "name": "tag1", "type": "string"},
+            {"indexed": True, "internalType": "string", "name": "indexedTag1", "type": "string"},
+            {"indexed": False, "internalType": "string", "name": "tag1", "type": "string"},
             {"indexed": False, "internalType": "string", "name": "tag2", "type": "string"},
             {"indexed": False, "internalType": "string", "name": "endpoint", "type": "string"},
             {"indexed": False, "internalType": "string", "name": "feedbackURI", "type": "string"},

agent0_sdk/core/feedback_manager.py

@@ -8,7 +8,7 @@ import json
 import logging
 import time
 from typing import Any, Dict, List, Optional, Tuple, Union
-from datetime import datetime
+from datetime import datetime, timezone
 
 from .models import (
     AgentId, Address, URI, Timestamp, IdemKey,
@@ -40,77 +40,66 @@ class FeedbackManager:
         self.subgraph_client = subgraph_client
         self.indexer = indexer
 
-    def prepareFeedback(
-        self,
-        agentId: AgentId,
-        score: Optional[int] = None,  # 0-100
-        tags: List[str] = None,
-        text: Optional[str] = None,
-        capability: Optional[str] = None,
-        name: Optional[str] = None,
-        skill: Optional[str] = None,
-        task: Optional[str] = None,
-        endpoint: Optional[str] = None,
-        domain: Optional[str] = None,
-        context: Optional[Dict[str, Any]] = None,
-        proofOfPayment: Optional[Dict[str, Any]] = None,
-        extra: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        """Prepare feedback file (local file/object) according to spec."""
-        if tags is None:
-            tags = []
-        
-        # Parse agent ID to get token ID
-        if ":" in agentId:
-            tokenId = int(agentId.split(":")[-1])
-        else:
-            tokenId = int(agentId)
-        
-        # Get current timestamp in ISO format
-        createdAt = datetime.fromtimestamp(time.time()).isoformat() + "Z"
-        
-        # Build feedback data according to spec
-        feedbackData = {
-            # MUST FIELDS
-            "agentRegistry": f"eip155:{self.web3_client.chain_id}:{self.identity_registry.address if self.identity_registry else '0x0'}",
-            "agentId": tokenId,
-            "clientAddress": f"eip155:{self.web3_client.chain_id}:{self.web3_client.account.address}",
-            "createdAt": createdAt,
-            "score": int(score) if score else 0,  # Score as integer (0-100)
-            
-            # MAY FIELDS
-            "tag1": tags[0] if tags else None,
-            "tag2": tags[1] if len(tags) > 1 else None,
-            "endpoint": endpoint,
-            "domain": domain,
-            "skill": skill,
-            "context": context,
-            "task": task,
-            "capability": capability,
-            "name": name,
-            "proofOfPayment": proofOfPayment,
-        }
-        
-        # Remove None values to keep the structure clean
-        feedbackData = {k: v for k, v in feedbackData.items() if v is not None}
+    def prepareFeedbackFile(self, input: Dict[str, Any]) -> Dict[str, Any]:
+        """Prepare an off-chain feedback file payload (no on-chain fields).
         
-        if extra:
-            feedbackData.update(extra)
+        This intentionally does NOT attempt to represent on-chain fields like:
+        score/tag1/tag2/endpoint (on-chain value), or registry-derived fields.
         
-        return feedbackData
+        It may validate/normalize and remove None values.
+        """
+        if input is None:
+            raise ValueError("prepareFeedbackFile input cannot be None")
+        if not isinstance(input, dict):
+            raise TypeError(f"prepareFeedbackFile input must be a dict, got {type(input)}")
+
+        # Shallow copy and strip None values
+        out: Dict[str, Any] = {k: v for k, v in dict(input).items() if v is not None}
+
+        # Minimal normalization for known optional fields
+        if "endpoint" in out and out["endpoint"] is not None and not isinstance(out["endpoint"], str):
+            out["endpoint"] = str(out["endpoint"])
+        if "domain" in out and out["domain"] is not None and not isinstance(out["domain"], str):
+            out["domain"] = str(out["domain"])
+
+        return out
 
     def giveFeedback(
         self,
         agentId: AgentId,
-        feedbackFile: Dict[str, Any],
-        idem: Optional[IdemKey] = None,
+        score: int,
+        tag1: Optional[str] = None,
+        tag2: Optional[str] = None,
+        endpoint: Optional[str] = None,
+        feedbackFile: Optional[Dict[str, Any]] = None,
     ) -> Feedback:
         """Give feedback (maps 8004 endpoint)."""
-        # Parse agent ID
-        if ":" in agentId:
-            tokenId = int(agentId.split(":")[-1])
+        # Parse agentId into (chainId, tokenId)
+        agent_chain_id: Optional[int] = None
+        tokenId: int
+        if isinstance(agentId, str) and agentId.startswith("eip155:"):
+            parts = agentId.split(":")
+            if len(parts) != 3:
+                raise ValueError(f"Invalid AgentId (expected eip155:chainId:tokenId): {agentId}")
+            agent_chain_id = int(parts[1])
+            tokenId = int(parts[2])
+        elif isinstance(agentId, str) and ":" in agentId:
+            parts = agentId.split(":")
+            if len(parts) != 2:
+                raise ValueError(f"Invalid AgentId (expected chainId:tokenId): {agentId}")
+            agent_chain_id = int(parts[0])
+            tokenId = int(parts[1])
         else:
             tokenId = int(agentId)
+            agent_chain_id = int(self.web3_client.chain_id)
+
+        # Ensure we are submitting the tx on the agent's chain
+        if int(self.web3_client.chain_id) != int(agent_chain_id):
+            raise ValueError(
+                f"Chain mismatch for giveFeedback: agentId={agentId} targets chainId={agent_chain_id}, "
+                f"but web3 client is connected to chainId={self.web3_client.chain_id}. "
+                f"Initialize the SDK/Web3Client for chainId={agent_chain_id}."
+            )
         
         # Get client address (the one giving feedback)
         # Keep in checksum format for blockchain calls (web3.py requirement)
@@ -128,30 +117,94 @@ class FeedbackManager:
         except Exception as e:
             raise ValueError(f"Failed to get feedback index: {e}")
         
-        # Prepare on-chain data
-        score = feedbackFile.get("score", 0)  # Already in 0-100 range
-        tag1 = feedbackFile.get("tag1", "") or ""
-        tag2 = feedbackFile.get("tag2", "") or ""
-        endpoint = feedbackFile.get("endpoint", "") or ""
+        if score is None:
+            raise ValueError("score is required")
+        if not isinstance(score, int):
+            # Allow numeric strings / floats if passed accidentally
+            score = int(score)
+
+        tag1 = tag1 or ""
+        tag2 = tag2 or ""
+
+        feedback_file: Optional[Dict[str, Any]] = feedbackFile
+        if feedback_file is not None and not isinstance(feedback_file, dict):
+            raise TypeError(f"feedbackFile must be a dict when provided, got {type(feedback_file)}")
+
+        # Endpoint precedence: explicit arg > file endpoint > empty string
+        if endpoint:
+            endpoint_onchain = endpoint
+        elif feedback_file and isinstance(feedback_file.get("endpoint"), str) and feedback_file.get("endpoint"):
+            endpoint_onchain = feedback_file.get("endpoint")
+        else:
+            endpoint_onchain = ""
+
+        # If uploading a file and we have an explicit endpoint, inject it for consistency
+        if feedback_file is not None and endpoint and isinstance(endpoint, str):
+            feedback_file = dict(feedback_file)
+            feedback_file["endpoint"] = endpoint
         
         # Handle off-chain file storage
         feedbackUri = ""
         feedbackHash = b"\x00" * 32  # Default empty hash
         
-        if self.ipfs_client:
-            # Store feedback file on IPFS using Filecoin Pin
+        if feedback_file is not None:
+            if not self.ipfs_client:
+                raise ValueError("feedbackFile was provided, but no IPFS client is configured")
+
+            # Store an ERC-8004 compliant feedback file on IPFS (explicit opt-in)
             try:
                 logger.debug("Storing feedback file on IPFS")
-                cid = self.ipfs_client.add_json(feedbackFile)
+                # createdAt MUST be present in the off-chain file; use provided value if valid, else now (UTC).
+                created_at = feedback_file.get("createdAt")
+                if not isinstance(created_at, str) or not created_at:
+                    created_at = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+                identity_registry_address = "0x0"
+                try:
+                    if self.identity_registry is not None:
+                        identity_registry_address = str(getattr(self.identity_registry, "address", "0x0"))
+                except Exception:
+                    identity_registry_address = "0x0"
+
+                # Remove any user-provided copies of the envelope keys; SDK-owned values must win
+                rich = dict(feedback_file)
+                for k in [
+                    "agentRegistry",
+                    "agentId",
+                    "clientAddress",
+                    "createdAt",
+                    "score",
+                    "tag1",
+                    "tag2",
+                    "endpoint",
+                ]:
+                    rich.pop(k, None)
+
+                file_for_storage: Dict[str, Any] = {
+                    # MUST fields (spec)
+                    "agentRegistry": f"eip155:{agent_chain_id}:{identity_registry_address}",
+                    "agentId": tokenId,
+                    "clientAddress": f"eip155:{agent_chain_id}:{clientAddress}",
+                    "createdAt": created_at,
+                    "score": int(score),
+
+                    # OPTIONAL fields that mirror on-chain
+                    **({"tag1": tag1} if tag1 else {}),
+                    **({"tag2": tag2} if tag2 else {}),
+                    **({"endpoint": endpoint_onchain} if endpoint_onchain else {}),
+
+                    # Rich/off-chain fields
+                    **rich,
+                }
+
+                cid = self.ipfs_client.addFeedbackFile(file_for_storage)
                 feedbackUri = f"ipfs://{cid}"
-                feedbackHash = self.web3_client.keccak256(json.dumps(feedbackFile, sort_keys=True).encode())
+                feedbackHash = self.web3_client.keccak256(
+                    json.dumps(file_for_storage, sort_keys=True).encode()
+                )
                 logger.debug(f"Feedback file stored on IPFS: {cid}")
             except Exception as e:
-                logger.warning(f"Failed to store feedback on IPFS: {e}")
-                # Continue without IPFS storage
-        elif feedbackFile.get("context") or feedbackFile.get("capability") or feedbackFile.get("name"):
-            # If we have rich data but no IPFS, we need to store it somewhere
-            raise ValueError("Rich feedback data requires IPFS client for storage")
+                raise ValueError(f"Failed to store feedback on IPFS: {e}")
         
         # Submit to blockchain with new signature: giveFeedback(agentId, score, tag1, tag2, endpoint, feedbackURI, feedbackHash)
         try:
@@ -162,7 +215,7 @@ class FeedbackManager:
                 score,
                 tag1,
                 tag2,
-                endpoint,
+                endpoint_onchain,
                 feedbackUri,
                 feedbackHash
             )
@@ -176,24 +229,25 @@ class FeedbackManager:
         # Create feedback object (address normalization happens in Feedback.create_id)
         feedbackId = Feedback.create_id(agentId, clientAddress, feedbackIndex)
         
+        ff: Dict[str, Any] = feedback_file or {}
         return Feedback(
             id=feedbackId,
             agentId=agentId,
             reviewer=clientAddress,  # create_id normalizes the ID; reviewer field can remain as-is
             score=int(score) if score and score > 0 else None,
             tags=[tag1, tag2] if tag1 or tag2 else [],
-            text=feedbackFile.get("text"),
-            context=feedbackFile.get("context"),
-            proofOfPayment=feedbackFile.get("proofOfPayment"),
+            text=ff.get("text"),
+            context=ff.get("context"),
+            proofOfPayment=ff.get("proofOfPayment"),
             fileURI=feedbackUri if feedbackUri else None,
-            endpoint=endpoint if endpoint else None,
+            endpoint=endpoint_onchain if endpoint_onchain else None,
             createdAt=int(time.time()),
             isRevoked=False,
             # Off-chain only fields
-            capability=feedbackFile.get("capability"),
-            name=feedbackFile.get("name"),
-            skill=feedbackFile.get("skill"),
-            task=feedbackFile.get("task")
+            capability=ff.get("capability"),
+            name=ff.get("name"),
+            skill=ff.get("skill"),
+            task=ff.get("task")
         )
 
     def getFeedback(
@@ -210,14 +264,14 @@ class FeedbackManager:
             except Exception as e:
                 logger.debug(f"Indexer/subgraph get_feedback failed, falling back to blockchain: {e}")
                 return self._get_feedback_from_blockchain(agentId, clientAddress, feedbackIndex)
-
+        
         if self.subgraph_client:
             try:
                 return self._get_feedback_from_subgraph(agentId, clientAddress, feedbackIndex)
             except Exception as e:
                 logger.debug(f"Subgraph get feedback failed, falling back to blockchain: {e}")
                 return self._get_feedback_from_blockchain(agentId, clientAddress, feedbackIndex)
-
+        
         return self._get_feedback_from_blockchain(agentId, clientAddress, feedbackIndex)
     
     def _get_feedback_from_subgraph(
@@ -267,9 +321,9 @@ class FeedbackManager:
             tag1 = feedback_data.get('tag1') or feedback_file.get('tag1')
             tag2 = feedback_data.get('tag2') or feedback_file.get('tag2')
             if isinstance(tag1, str) and tag1:
-                tags.append(tag1)
+                    tags.append(tag1)
             if isinstance(tag2, str) and tag2:
-                tags.append(tag2)
+                    tags.append(tag2)
             
             return Feedback(
                 id=Feedback.create_id(agentId, clientAddress, feedbackIndex),  # create_id now normalizes
@@ -287,7 +341,8 @@ class FeedbackManager:
                     'txHash': feedback_file.get('proofOfPaymentTxHash'),
                 } if feedback_file.get('proofOfPaymentFromAddress') else None,
                 fileURI=feedback_data.get('feedbackURI') or feedback_data.get('feedbackUri'),  # Handle both old and new field names
-                endpoint=feedback_data.get('endpoint'),
+                # Prefer on-chain endpoint; fall back to off-chain file endpoint if missing
+                endpoint=feedback_data.get('endpoint') or feedback_file.get('endpoint'),
                 createdAt=feedback_data.get('createdAt', int(time.time())),
                 answers=answers,
                 isRevoked=feedback_data.get('isRevoked', False),
@@ -509,9 +564,9 @@ class FeedbackManager:
             tag1 = fb_data.get('tag1') or feedback_file.get('tag1')
             tag2 = fb_data.get('tag2') or feedback_file.get('tag2')
             if isinstance(tag1, str) and tag1:
-                tags_list.append(tag1)
+                    tags_list.append(tag1)
             if isinstance(tag2, str) and tag2:
-                tags_list.append(tag2)
+                    tags_list.append(tag2)
             
             # Parse agentId from feedback ID
             feedback_id = fb_data['id']

agent0_sdk/core/indexer.py

@@ -1094,7 +1094,8 @@ class AgentIndexer:
                 'txHash': feedback_file.get('proofOfPaymentTxHash'),
             } if feedback_file.get('proofOfPaymentFromAddress') else None,
             fileURI=feedback_data.get('feedbackURI') or feedback_data.get('feedbackUri'),  # Handle both old and new field names
-            endpoint=feedback_data.get('endpoint'),
+            # Prefer on-chain endpoint; fall back to off-chain file endpoint if missing
+            endpoint=feedback_data.get('endpoint') or feedback_file.get('endpoint'),
             createdAt=feedback_data.get('createdAt', int(time.time())),
             answers=answers,
             isRevoked=feedback_data.get('isRevoked', False),

agent0_sdk/core/ipfs_client.py

@@ -160,7 +160,7 @@ class IPFSClient:
         # add_str returns the CID directly as a string
         return result if isinstance(result, str) else result['Hash']
 
-    def _pin_to_pinata(self, data: str) -> str:
+    def _pin_to_pinata(self, data: str, file_name: str = "file.json") -> str:
         """Pin data to Pinata using JWT authentication with v3 API."""
         import requests
         import tempfile
@@ -185,7 +185,7 @@ class IPFSClient:
             # Prepare the file for upload with public network setting
             with open(temp_path, 'rb') as file:
                 files = {
-                    'file': ('registration.json', file, 'application/json')
+                    'file': (file_name, file, 'application/json')
                 }
                 
                 # Add network parameter to make file public
@@ -233,8 +233,9 @@ class IPFSClient:
 
     def add(self, data: str, **kwargs) -> str:
         """Add data to IPFS and return CID."""
+        file_name = kwargs.pop("file_name", None)
         if self.pinata_enabled:
-            return self._pin_to_pinata(data)
+            return self._pin_to_pinata(data, file_name=file_name or "file.json")
         elif self.filecoin_pin_enabled:
             # Create temporary file for Filecoin Pin
             with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
@@ -251,11 +252,12 @@ class IPFSClient:
 
     def add_file(self, filepath: str, **kwargs) -> str:
         """Add file to IPFS and return CID."""
+        file_name = kwargs.pop("file_name", None)
         if self.pinata_enabled:
             # Read file and send to Pinata
             with open(filepath, 'r') as f:
                 data = f.read()
-            return self._pin_to_pinata(data)
+            return self._pin_to_pinata(data, file_name=file_name or "file.json")
         elif self.filecoin_pin_enabled:
             return self._pin_to_filecoin(filepath)
         else:
@@ -332,7 +334,7 @@ class IPFSClient:
     def addRegistrationFile(self, registrationFile: "RegistrationFile", chainId: Optional[int] = None, identityRegistryAddress: Optional[str] = None, **kwargs) -> str:
         """Add registration file to IPFS and return CID."""
         data = registrationFile.to_dict(chain_id=chainId, identity_registry_address=identityRegistryAddress)
-        return self.add_json(data, **kwargs)
+        return self.add_json(data, file_name="agent-registration.json", **kwargs)
 
     def getRegistrationFile(self, cid: str) -> "RegistrationFile":
         """Get registration file from IPFS by CID."""
@@ -342,7 +344,7 @@ class IPFSClient:
 
     def addFeedbackFile(self, feedbackData: Dict[str, Any], **kwargs) -> str:
         """Add feedback file to IPFS and return CID."""
-        return self.add_json(feedbackData, **kwargs)
+        return self.add_json(feedbackData, file_name="feedback.json", **kwargs)
 
     def getFeedbackFile(self, cid: str) -> Dict[str, Any]:
         """Get feedback file from IPFS by CID."""

agent0_sdk/core/sdk.py

@@ -491,111 +491,8 @@ class SDK:
 
         return self.indexer.search_agents(params, sort, page_size, cursor)
 
-    # Feedback methods
-    def prepareFeedback(
-        self,
-        agentId: AgentId,
-        score: Optional[int] = None,  # 0-100
-        tags: List[str] = None,
-        text: Optional[str] = None,
-        capability: Optional[str] = None,
-        name: Optional[str] = None,
-        skill: Optional[str] = None,
-        task: Optional[str] = None,
-        context: Optional[Dict[str, Any]] = None,
-        proofOfPayment: Optional[Dict[str, Any]] = None,
-        extra: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        """Prepare feedback file (local file/object)."""
-        return self.feedback_manager.prepareFeedback(
-            agentId=agentId,
-            score=score,
-            tags=tags,
-            text=text,
-            capability=capability,
-            name=name,
-            skill=skill,
-            task=task,
-            context=context,
-            proofOfPayment=proofOfPayment,
-            extra=extra
-        )
-
-    def giveFeedback(
-        self,
-        agentId: AgentId,
-        feedbackFile: Dict[str, Any],
-        idem: Optional[IdemKey] = None,
-        feedback_auth: Optional[bytes] = None,
-    ) -> Feedback:
-        """Give feedback (maps 8004 endpoint)."""
-        return self.feedback_manager.giveFeedback(
-            agentId=agentId,
-            feedbackFile=feedbackFile,
-            idem=idem,
-            feedback_auth=feedback_auth
-        )
-
-    def getFeedback(self, feedbackId: str) -> Feedback:
-        """Get single feedback by ID string."""
-        # Parse feedback ID
-        agentId, clientAddress, feedbackIndex = Feedback.from_id_string(feedbackId)
-        return self.feedback_manager.getFeedback(agentId, clientAddress, feedbackIndex)
-
-    def searchFeedback(
-        self,
-        agentId: AgentId,
-        reviewers: Optional[List[Address]] = None,
-        tags: Optional[List[str]] = None,
-        capabilities: Optional[List[str]] = None,
-        skills: Optional[List[str]] = None,
-        tasks: Optional[List[str]] = None,
-        names: Optional[List[str]] = None,
-        minScore: Optional[int] = None,
-        maxScore: Optional[int] = None,
-        include_revoked: bool = False,
-        first: int = 100,
-        skip: int = 0,
-    ) -> List[Feedback]:
-        """Search feedback for an agent."""
-        return self.feedback_manager.searchFeedback(
-            agentId=agentId,
-            clientAddresses=reviewers,
-            tags=tags,
-            capabilities=capabilities,
-            skills=skills,
-            tasks=tasks,
-            names=names,
-            minScore=minScore,
-            maxScore=maxScore,
-            include_revoked=include_revoked,
-            first=first,
-            skip=skip
-        )
-
-    def revokeFeedback(
-        self,
-        feedbackId: str,
-        reason: Optional[str] = None,
-        idem: Optional[IdemKey] = None,
-    ) -> Dict[str, Any]:
-        """Revoke feedback."""
-        # Parse feedback ID
-        agentId, clientAddress, feedbackIndex = Feedback.from_id_string(feedbackId)
-        return self.feedback_manager.revokeFeedback(agentId, feedbackIndex)
-
-    def appendResponse(
-        self,
-        feedbackId: str,
-        response: Dict[str, Any],
-        idem: Optional[IdemKey] = None,
-    ) -> Feedback:
-        """Append a response/follow-up to existing feedback."""
-        # Parse feedback ID
-        agentId, clientAddress, feedbackIndex = Feedback.from_id_string(feedbackId)
-        return self.feedback_manager.appendResponse(agentId, clientAddress, feedbackIndex, response)
+    # Feedback methods are defined later in this class (single authoritative API).
 
-    
     def searchAgentsByReputation(
         self,
         agents: Optional[List[AgentId]] = None,
@@ -884,46 +781,35 @@ class SDK:
         }
     
     # Feedback methods - delegate to feedback_manager
-    def signFeedbackAuth(
-        self,
-        agentId: "AgentId",
-        clientAddress: "Address",
-        indexLimit: Optional[int] = None,
-        expiryHours: int = 24,
-    ) -> bytes:
-        """Sign feedback authorization for a client."""
-        return self.feedback_manager.signFeedbackAuth(
-            agentId, clientAddress, indexLimit, expiryHours
-        )
-    
-    def prepareFeedback(
-        self,
-        agentId: "AgentId",
-        score: Optional[int] = None,  # 0-100
-        tags: List[str] = None,
-        text: Optional[str] = None,
-        capability: Optional[str] = None,
-        name: Optional[str] = None,
-        skill: Optional[str] = None,
-        task: Optional[str] = None,
-        context: Optional[Dict[str, Any]] = None,
-        proofOfPayment: Optional[Dict[str, Any]] = None,
-        extra: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        """Prepare feedback file (local file/object) according to spec."""
-        return self.feedback_manager.prepareFeedback(
-            agentId, score, tags, text, capability, name, skill, task, context, proofOfPayment, extra
-        )
+    def prepareFeedbackFile(self, input: Dict[str, Any]) -> Dict[str, Any]:
+        """Prepare an off-chain feedback file payload.
+        
+        This is intentionally off-chain-only; it does not attempt to represent
+        the on-chain fields (score/tag1/tag2/endpoint-on-chain).
+        """
+        return self.feedback_manager.prepareFeedbackFile(input)
     
     def giveFeedback(
         self,
         agentId: "AgentId",
-        feedbackFile: Dict[str, Any],
-        idem: Optional["IdemKey"] = None,
+        score: int,
+        tag1: Optional[str] = None,
+        tag2: Optional[str] = None,
+        endpoint: Optional[str] = None,
+        feedbackFile: Optional[Dict[str, Any]] = None,
     ) -> "Feedback":
-        """Give feedback (maps 8004 endpoint)."""
+        """Give feedback (on-chain first; optional off-chain file upload).
+        
+        - If feedbackFile is None: submit on-chain only (no upload even if IPFS is configured).
+        - If feedbackFile is provided: requires IPFS configured; uploads and commits URI/hash on-chain.
+        """
         return self.feedback_manager.giveFeedback(
-            agentId, feedbackFile, idem
+            agentId=agentId,
+            score=score,
+            tag1=tag1,
+            tag2=tag2,
+            endpoint=endpoint,
+            feedbackFile=feedbackFile,
         )
     
     def getFeedback(
@@ -936,6 +822,37 @@ class SDK:
         return self.feedback_manager.getFeedback(
             agentId, clientAddress, feedbackIndex
         )
+
+    def searchFeedback(
+        self,
+        agentId: "AgentId",
+        reviewers: Optional[List["Address"]] = None,
+        tags: Optional[List[str]] = None,
+        capabilities: Optional[List[str]] = None,
+        skills: Optional[List[str]] = None,
+        tasks: Optional[List[str]] = None,
+        names: Optional[List[str]] = None,
+        minScore: Optional[int] = None,
+        maxScore: Optional[int] = None,
+        include_revoked: bool = False,
+        first: int = 100,
+        skip: int = 0,
+    ) -> List["Feedback"]:
+        """Search feedback for an agent."""
+        return self.feedback_manager.searchFeedback(
+            agentId=agentId,
+            clientAddresses=reviewers,
+            tags=tags,
+            capabilities=capabilities,
+            skills=skills,
+            tasks=tasks,
+            names=names,
+            minScore=minScore,
+            maxScore=maxScore,
+            include_revoked=include_revoked,
+            first=first,
+            skip=skip,
+        )
     
     def revokeFeedback(
         self,

{agent0_sdk-1.0.1.dist-info → agent0_sdk-1.0.2.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: agent0-sdk
-Version: 1.0.1
+Version: 1.0.2
 Summary: Python SDK for agent portability, discovery and trust based on ERC-8004
-Author-email: Marco De Rossi <marco@ag0.xyz>
+Author-email: Agent0 Team <team@ag0.xyz>
 License: MIT License
         
         Copyright (c) 2025 Marco De Rossi
@@ -86,7 +86,7 @@ Agent0 SDK enables you to:
 - **Cross-chain registration** - One-line registration with IPFS nodes, Pinata, Filecoin, or HTTP URIs
 - **Public indexing** - Subgraph indexing both on-chain and IPFS data for fast search and retrieval
 
-**Bug reports & feedback:** GitHub: [Report issues](https://github.com/agent0lab/agent0-py/issues) | Telegram: [@marcoderossi](https://t.me/marcoderossi) | Email: marco@ag0.xyz
+**Bug reports & feedback:** GitHub: [Report issues](https://github.com/agent0lab/agent0-py/issues) | Telegram: [Agent0 channel](https://t.me/agent0kitchen) | Email: team@ag0.xyz
 
 ## Installation
 
@@ -213,19 +213,31 @@ agent_summary = sdk.getAgent("11155111:123")
 ### 5. Give and Retrieve Feedback
 
 ```python
-# Prepare feedback (only score is mandatory)
-feedback_file = sdk.prepareFeedback(
+# On-chain-only feedback (no off-chain upload, even if IPFS is configured)
+feedback = sdk.giveFeedback(
     agentId="11155111:123",
     score=85,  # 0-100 (mandatory)
-    tags=["data_analyst", "finance"],  # Optional: tags are now strings (not bytes32)
-    endpoint="https://example.com/endpoint",  # Optional: endpoint URI associated with feedback
-    capability="tools",  # Optional: MCP capability
-    name="code_generation",  # Optional: MCP tool name
-    skill="python"  # Optional: A2A skill
+    tag1="data_analyst",  # Optional: tags are strings
+    tag2="finance",
+    endpoint="https://example.com/endpoint",  # Optional: saved on-chain
 )
 
-# Give feedback
-feedback = sdk.giveFeedback(agentId="11155111:123", feedbackFile=feedback_file)
+# Rich feedback (optional off-chain file + on-chain fields)
+feedback_file = sdk.prepareFeedbackFile({
+    "capability": "tools",       # Optional: MCP capability
+    "name": "code_generation",   # Optional: MCP tool name
+    "skill": "python",           # Optional: A2A skill
+    "text": "Great agent!",      # Optional
+})
+
+feedback = sdk.giveFeedback(
+    agentId="11155111:123",
+    score=85,
+    tag1="data_analyst",
+    tag2="finance",
+    endpoint="https://example.com/endpoint",
+    feedbackFile=feedback_file,  # If provided, requires IPFS configured
+)
 
 # Search feedback
 results = sdk.searchFeedback(
@@ -305,7 +317,7 @@ OASF skills and domains appear in your agent's registration file:
     {
       "name": "OASF",
       "endpoint": "https://github.com/agntcy/oasf/",
-      "version": "v0.8.0",
+      "version": "0.8",
       "skills": [
         "advanced_reasoning_planning/strategic_planning",
         "data_engineering/data_transformation_pipeline"

agent0_sdk-1.0.2.dist-info/RECORD

@@ -0,0 +1,19 @@
+agent0_sdk/__init__.py,sha256=qmIKaQIVmgJk0tOa-kGdj0qxdTKdb6msPnrIPX0SO-g,919
+agent0_sdk/core/agent.py,sha256=NJo0pjigXznP0zDIrpryrL7pMj5bVvZIhfv4abKtUKk,45157
+agent0_sdk/core/contracts.py,sha256=N7lN29zgV_sfValX8515OUm1Lvu6O185gK863dFPCj0,21717
+agent0_sdk/core/endpoint_crawler.py,sha256=QBkFc3tBSQqHj6PtSTZ5D3_HVB00KJZJdxE3uYpI9po,13611
+agent0_sdk/core/feedback_manager.py,sha256=RFl9EYa-GtLahYatIzMf-IOO_X3oLTCk5B6UH8CM_Ic,40704
+agent0_sdk/core/indexer.py,sha256=09NhrPM5dxaBWOsVgBwjzJFpg9Bg9hAastc2YQ0UmHM,70447
+agent0_sdk/core/ipfs_client.py,sha256=17XXMpJgLWhcNUSkmduAZt409c8oJXlj9C_eTGVk-Io,14185
+agent0_sdk/core/models.py,sha256=1BSAX2LVbw0kL_qHK7DxBrIFx8PF3wQvzkzblcQTMUg,12042
+agent0_sdk/core/oasf_validator.py,sha256=ZOtYYzQd7cJj3eJegi7Ch5ydoapJEjaJSxMvwzKSp5o,2980
+agent0_sdk/core/sdk.py,sha256=JhYBNj78JxGhPHeOVl9atdxDZqInnGKy2D5DylO4ImU,38223
+agent0_sdk/core/subgraph_client.py,sha256=VSK9gCB5uYc2OqAVQ659IgeF0N-tXwxPUbv7NK8Kz0U,29575
+agent0_sdk/core/web3_client.py,sha256=h7s-Al3E1xfbb3QNcPvmQBotKJRg23Jm9xot4emr-hU,12283
+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.0.2.dist-info/licenses/LICENSE,sha256=rhZZbZm_Ovz4Oa9LNQ-ms8a1tA36wWh90ZkC0OR7WMw,1072
+agent0_sdk-1.0.2.dist-info/METADATA,sha256=llO2PMTI8QMCcz-Lae0EjqlB9gZ6v_gwQfbGhVxnM24,14565
+agent0_sdk-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+agent0_sdk-1.0.2.dist-info/top_level.txt,sha256=p4520WUKNfhU0lVWJgkrB_jdeUfvHSY3K18k4oYLNfI,11
+agent0_sdk-1.0.2.dist-info/RECORD,,

agent0_sdk-1.0.1.dist-info/RECORD

@@ -1,19 +0,0 @@
-agent0_sdk/__init__.py,sha256=Rtb9_6FYcrqQw0sV7gmox6nj3W3IawaY4LLZriMbb20,919
-agent0_sdk/core/agent.py,sha256=L8pDTXUWZ5ZmFgGjBwdheKTvMcGu9SlUP9MQD9TQ0MU,45061
-agent0_sdk/core/contracts.py,sha256=euFfjnmpYHNfzzQFvYTvSI-xJGgzFTo2CNny6YaUKTg,21618
-agent0_sdk/core/endpoint_crawler.py,sha256=QBkFc3tBSQqHj6PtSTZ5D3_HVB00KJZJdxE3uYpI9po,13611
-agent0_sdk/core/feedback_manager.py,sha256=ndGROPISrQvfKjwrWiB_xJ9QIh0cLs4oHh666Ru-A_8,37650
-agent0_sdk/core/indexer.py,sha256=BUL4QbbL9sN8eZ1osUdIn_Kgj-MF0SET8RtjbBERQm0,70326
-agent0_sdk/core/ipfs_client.py,sha256=fml1ai1BdBkgb95xAkf-ft8QsahV1HL30hBYRz7rQwI,13929
-agent0_sdk/core/models.py,sha256=1BSAX2LVbw0kL_qHK7DxBrIFx8PF3wQvzkzblcQTMUg,12042
-agent0_sdk/core/oasf_validator.py,sha256=ZOtYYzQd7cJj3eJegi7Ch5ydoapJEjaJSxMvwzKSp5o,2980
-agent0_sdk/core/sdk.py,sha256=c9vSKTer50aJr8VcJ6huj6N1pTRwCUtbCxl5G_5oXhk,40955
-agent0_sdk/core/subgraph_client.py,sha256=VSK9gCB5uYc2OqAVQ659IgeF0N-tXwxPUbv7NK8Kz0U,29575
-agent0_sdk/core/web3_client.py,sha256=h7s-Al3E1xfbb3QNcPvmQBotKJRg23Jm9xot4emr-hU,12283
-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.0.1.dist-info/licenses/LICENSE,sha256=rhZZbZm_Ovz4Oa9LNQ-ms8a1tA36wWh90ZkC0OR7WMw,1072
-agent0_sdk-1.0.1.dist-info/METADATA,sha256=WkgYGLtZzuaE57yJqmVS0pyNPcb0ByNfaWNBHfR0qI0,14268
-agent0_sdk-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-agent0_sdk-1.0.1.dist-info/top_level.txt,sha256=p4520WUKNfhU0lVWJgkrB_jdeUfvHSY3K18k4oYLNfI,11
-agent0_sdk-1.0.1.dist-info/RECORD,,