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

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,
@@ -16,6 +16,7 @@ from .models import (
 )
 from .web3_client import Web3Client
 from .ipfs_client import IPFSClient
+from .value_encoding import encode_feedback_value, decode_feedback_value
 
 logger = logging.getLogger(__name__)
 
@@ -40,77 +41,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:
+        value/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,
+        value: Union[int, float, str],
+        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,41 +118,105 @@ 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 ""
+        value_raw, value_decimals, _normalized = encode_feedback_value(value)
+
+        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",
+                    "value",
+                    "valueDecimals",
+                    "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,
+                    # On-chain fields (store raw+decimals for precision)
+                    "value": str(value_raw),
+                    "valueDecimals": int(value_decimals),
+
+                    # 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)
+        # Submit to blockchain with new signature: giveFeedback(agentId, value, valueDecimals, tag1, tag2, endpoint, feedbackURI, feedbackHash)
         try:
             txHash = self.web3_client.transact_contract(
                 self.reputation_registry,
                 "giveFeedback",
                 tokenId,
-                score,
+                value_raw,
+                value_decimals,
                 tag1,
                 tag2,
-                endpoint,
+                endpoint_onchain,
                 feedbackUri,
                 feedbackHash
             )
@@ -176,24 +230,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,
+            value=decode_feedback_value(value_raw, value_decimals),
             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 +265,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,15 +322,15 @@ 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
                 agentId=agentId,
                 reviewer=self.web3_client.normalize_address(clientAddress),  # Also normalize reviewer field
-                score=feedback_data.get('score'),
+                value=float(feedback_data.get("value")) if feedback_data.get("value") is not None else None,
                 tags=tags,
                 text=feedback_file.get('text'),
                 capability=feedback_file.get('capability'),
@@ -287,7 +342,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),
@@ -322,7 +378,7 @@ class FeedbackManager:
                 feedbackIndex
             )
             
-            score, tag1, tag2, is_revoked = result
+            value_raw, value_decimals, tag1, tag2, is_revoked = result
             
             # Create feedback object (normalize address for consistency)
             normalized_address = self.web3_client.normalize_address(clientAddress)
@@ -339,7 +395,7 @@ class FeedbackManager:
                 id=feedbackId,
                 agentId=agentId,
                 reviewer=normalized_address,
-                score=int(score) if score and score > 0 else None,
+                value=decode_feedback_value(int(value_raw), int(value_decimals)),
                 tags=tags,
                 text=None,  # Not stored on-chain
                 capability=None,  # Not stored on-chain
@@ -363,8 +419,8 @@ class FeedbackManager:
         skills: Optional[List[str]] = None,
         tasks: Optional[List[str]] = None,
         names: Optional[List[str]] = None,
-        minScore: Optional[int] = None,
-        maxScore: Optional[int] = None,
+        minValue: Optional[float] = None,
+        maxValue: Optional[float] = None,
         include_revoked: bool = False,
         first: int = 100,
         skip: int = 0,
@@ -376,14 +432,14 @@ class FeedbackManager:
             # This enables future semantic search capabilities
             return self.indexer.search_feedback(
                 agentId, clientAddresses, tags, capabilities, skills, tasks, names,
-                minScore, maxScore, include_revoked, first, skip
+                minValue, maxValue, include_revoked, first, skip
             )
         
         # Fallback: direct subgraph access (if indexer not available)
         if self.subgraph_client:
             return self._search_feedback_subgraph(
                 agentId, clientAddresses, tags, capabilities, skills, tasks, names,
-                minScore, maxScore, include_revoked, first, skip
+                minValue, maxValue, include_revoked, first, skip
             )
         
         # Fallback to blockchain
@@ -399,7 +455,7 @@ class FeedbackManager:
             tag1_filter = tags[0] if tags else ""
             tag2_filter = tags[1] if tags and len(tags) > 1 else ""
             
-            # Read from blockchain - new signature returns: (clientAddresses, feedbackIndexes, scores, tag1s, tag2s, revokedStatuses)
+            # Read from blockchain - signature returns: (clients, feedbackIndexes, values, valueDecimals, tag1s, tag2s, revokedStatuses)
             result = self.web3_client.call_contract(
                 self.reputation_registry,
                 "readAllFeedback",
@@ -410,7 +466,7 @@ class FeedbackManager:
                 include_revoked
             )
             
-            clients, feedback_indexes, scores, tag1s, tag2s, revoked_statuses = result
+            clients, feedback_indexes, values, value_decimals, tag1s, tag2s, revoked_statuses = result
             
             # Convert to Feedback objects
             feedbacks = []
@@ -429,7 +485,7 @@ class FeedbackManager:
                     id=feedbackId,
                     agentId=agentId,
                     reviewer=clients[i],
-                    score=int(scores[i]) if scores[i] and scores[i] > 0 else None,
+                    value=decode_feedback_value(int(values[i]), int(value_decimals[i])),
                     tags=tags_list,
                     text=None,
                     capability=None,
@@ -456,8 +512,8 @@ class FeedbackManager:
         skills: Optional[List[str]],
         tasks: Optional[List[str]],
         names: Optional[List[str]],
-        minScore: Optional[int],
-        maxScore: Optional[int],
+        minValue: Optional[float],
+        maxValue: Optional[float],
         include_revoked: bool,
         first: int,
         skip: int,
@@ -472,8 +528,8 @@ class FeedbackManager:
             skills=skills,
             tasks=tasks,
             names=names,
-            minScore=minScore,
-            maxScore=maxScore,
+            minValue=minValue,
+            maxValue=maxValue,
             includeRevoked=include_revoked
         )
         
@@ -509,9 +565,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']
@@ -529,7 +585,7 @@ class FeedbackManager:
                 id=Feedback.create_id(agent_id_str, client_addr, feedback_idx),
                 agentId=agent_id_str,
                 reviewer=client_addr,
-                score=fb_data.get('score'),
+                value=float(fb_data.get("value")) if fb_data.get("value") is not None else None,
                 tags=tags_list,
                 text=feedback_file.get('text'),
                 capability=feedback_file.get('capability'),
@@ -702,14 +758,15 @@ class FeedbackManager:
                 tag2_str
             )
             
-            count, average_score = result
+            count, summary_value, summary_value_decimals = result
+            average_value = decode_feedback_value(int(summary_value), int(summary_value_decimals))
             
             # If no grouping requested, return simple summary
             if not groupBy:
                 return {
                     "agentId": agentId,
                     "count": count,
-                    "averageScore": float(average_score) / 100.0 if average_score > 0 else 0.0,
+                    "averageValue": average_value,
                     "filters": {
                         "clientAddresses": clientAddresses,
                         "tag1": tag1,
@@ -731,7 +788,7 @@ class FeedbackManager:
             return {
                 "agentId": agentId,
                 "totalCount": count,
-                "totalAverageScore": float(average_score) / 100.0 if average_score > 0 else 0.0,
+                "totalAverageValue": average_value,
                 "groupedData": grouped_data,
                 "filters": {
                     "clientAddresses": clientAddresses,
@@ -773,15 +830,15 @@ class FeedbackManager:
         
         # Calculate summary statistics
         count = len(all_feedback)
-        scores = [fb.score for fb in all_feedback if fb.score is not None]
-        average_score = sum(scores) / len(scores) if scores else 0.0
+        values = [fb.value for fb in all_feedback if fb.value is not None]
+        average_value = sum(values) / len(values) if values else 0.0
         
         # If no grouping requested, return simple summary
         if not groupBy:
             return {
                 "agentId": agentId,
                 "count": count,
-                "averageScore": average_score,
+                "averageValue": average_value,
                 "filters": {
                     "clientAddresses": clientAddresses,
                     "tag1": tag1,
@@ -795,7 +852,7 @@ class FeedbackManager:
         return {
             "agentId": agentId,
             "totalCount": count,
-            "totalAverageScore": average_score,
+            "totalAverageValue": average_value,
             "groupedData": grouped_data,
             "filters": {
                 "clientAddresses": clientAddresses,
@@ -816,23 +873,23 @@ class FeedbackManager:
             if group_key not in grouped:
                 grouped[group_key] = {
                     "count": 0,
-                    "totalScore": 0.0,
-                    "averageScore": 0.0,
-                    "scores": [],
+                    "totalValue": 0.0,
+                    "averageValue": 0.0,
+                    "values": [],
                     "feedback": []
                 }
             
             # Add feedback to group
             grouped[group_key]["count"] += 1
-            if feedback.score is not None:
-                grouped[group_key]["totalScore"] += feedback.score
-                grouped[group_key]["scores"].append(feedback.score)
+            if feedback.value is not None:
+                grouped[group_key]["totalValue"] += float(feedback.value)
+                grouped[group_key]["values"].append(float(feedback.value))
             grouped[group_key]["feedback"].append(feedback)
         
         # Calculate averages for each group
         for group_data in grouped.values():
             if group_data["count"] > 0:
-                group_data["averageScore"] = group_data["totalScore"] / group_data["count"]
+                group_data["averageValue"] = group_data["totalValue"] / group_data["count"]
         
         return grouped
     

agent0_sdk/core/indexer.py

@@ -87,7 +87,7 @@ class AgentIndexer:
     def _create_default_embeddings(self):
         """Create default embeddings model."""
         try:
-            from sentence_transformers import SentenceTransformer
+            from sentence_transformers import SentenceTransformer  # type: ignore[import-not-found]
             return SentenceTransformer('all-MiniLM-L6-v2')
         except ImportError:
             # Return None if sentence-transformers is not available
@@ -260,7 +260,7 @@ class AgentIndexer:
             raise ValueError(f"Failed to get agent data: {e}")
 
         # Load registration file
-        registration_data = await self._load_registration_data(token_uri)
+        registration_data = await self._load_registration_data(agent_uri)
         
         # Create agent summary
         summary = self._create_agent_summary(
@@ -1082,7 +1082,7 @@ class AgentIndexer:
             id=Feedback.create_id(agentId, clientAddress, feedbackIndex),
             agentId=agentId,
             reviewer=self.web3_client.normalize_address(clientAddress),
-            score=feedback_data.get('score'),
+            value=float(feedback_data.get("value")) if feedback_data.get("value") is not None else None,
             tags=tags,
             text=feedback_file.get('text'),
             capability=feedback_file.get('capability'),
@@ -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),
@@ -1112,8 +1113,8 @@ class AgentIndexer:
         skills: Optional[List[str]] = None,
         tasks: Optional[List[str]] = None,
         names: Optional[List[str]] = None,
-        minScore: Optional[int] = None,
-        maxScore: Optional[int] = None,
+        minValue: Optional[float] = None,
+        maxValue: Optional[float] = None,
         include_revoked: bool = False,
         first: int = 100,
         skip: int = 0,
@@ -1139,7 +1140,7 @@ class AgentIndexer:
         if subgraph_client:
             return self._search_feedback_subgraph(
                 full_agent_id, clientAddresses, tags, capabilities, skills, tasks, names,
-                minScore, maxScore, include_revoked, first, skip, subgraph_client
+                minValue, maxValue, include_revoked, first, skip, subgraph_client
             )
         
         # Fallback not implemented (would require blockchain queries)
@@ -1155,8 +1156,8 @@ class AgentIndexer:
         skills: Optional[List[str]],
         tasks: Optional[List[str]],
         names: Optional[List[str]],
-        minScore: Optional[int],
-        maxScore: Optional[int],
+        minValue: Optional[float],
+        maxValue: Optional[float],
         include_revoked: bool,
         first: int,
         skip: int,
@@ -1177,8 +1178,8 @@ class AgentIndexer:
             skills=skills,
             tasks=tasks,
             names=names,
-            minScore=minScore,
-            maxScore=maxScore,
+            minValue=minValue,
+            maxValue=maxValue,
             includeRevoked=include_revoked
         )
         
@@ -1664,7 +1665,7 @@ class AgentIndexer:
         - updatedAt (timestamp)
         - totalFeedback (count)
         - name (alphabetical)
-        - averageScore (reputation, if available)
+        - averageValue (reputation, if available)
         """
         if not sort or len(sort) == 0:
             # Default: sort by createdAt descending (newest first)
@@ -1699,9 +1700,9 @@ class AgentIndexer:
                 reg_file = agent.get('registrationFile', {})
                 return reg_file.get('name', '').lower()
 
-            elif field == 'averageScore':
-                # If reputation search was done, averageScore may be available
-                return agent.get('averageScore', 0)
+            elif field == 'averageValue':
+                # If reputation search was done, averageValue may be available
+                return agent.get('averageValue', 0)
 
             else:
                 logger.warning(f"Unknown sort field: {field}, defaulting to createdAt")