agent0-sdk 0.3rc1__py3-none-any.whl → 0.5__py3-none-any.whl

agent0_sdk/core/oasf_validator.py

@@ -0,0 +1,98 @@
+"""
+OASF taxonomy validation utilities.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Optional
+
+# Cache for loaded taxonomy data
+_skills_cache: Optional[dict] = None
+_domains_cache: Optional[dict] = None
+
+
+def _get_taxonomy_path(filename: str) -> Path:
+    """Get the path to a taxonomy file."""
+    # Get the directory where this file is located
+    current_dir = Path(__file__).parent
+    # Go up one level to agent0_sdk, then into taxonomies
+    taxonomy_dir = current_dir.parent / "taxonomies"
+    return taxonomy_dir / filename
+
+
+def _load_skills() -> dict:
+    """Load skills taxonomy file with caching."""
+    global _skills_cache
+    if _skills_cache is None:
+        skills_path = _get_taxonomy_path("all_skills.json")
+        try:
+            with open(skills_path, "r", encoding="utf-8") as f:
+                _skills_cache = json.load(f)
+        except FileNotFoundError:
+            raise FileNotFoundError(
+                f"Skills taxonomy file not found: {skills_path}"
+            )
+        except json.JSONDecodeError as e:
+            raise ValueError(
+                f"Invalid JSON in skills taxonomy file: {e}"
+            )
+    return _skills_cache
+
+
+def _load_domains() -> dict:
+    """Load domains taxonomy file with caching."""
+    global _domains_cache
+    if _domains_cache is None:
+        domains_path = _get_taxonomy_path("all_domains.json")
+        try:
+            with open(domains_path, "r", encoding="utf-8") as f:
+                _domains_cache = json.load(f)
+        except FileNotFoundError:
+            raise FileNotFoundError(
+                f"Domains taxonomy file not found: {domains_path}"
+            )
+        except json.JSONDecodeError as e:
+            raise ValueError(
+                f"Invalid JSON in domains taxonomy file: {e}"
+            )
+    return _domains_cache
+
+
+def validate_skill(slug: str) -> bool:
+    """
+    Validate if a skill slug exists in the OASF taxonomy.
+    
+    Args:
+        slug: The skill slug to validate (e.g., "natural_language_processing/natural_language_generation/summarization")
+    
+    Returns:
+        True if the skill exists in the taxonomy, False otherwise
+    
+    Raises:
+        FileNotFoundError: If the taxonomy file cannot be found
+        ValueError: If the taxonomy file is invalid JSON
+    """
+    skills_data = _load_skills()
+    skills = skills_data.get("skills", {})
+    return slug in skills
+
+
+def validate_domain(slug: str) -> bool:
+    """
+    Validate if a domain slug exists in the OASF taxonomy.
+    
+    Args:
+        slug: The domain slug to validate (e.g., "finance_and_business/investment_services")
+    
+    Returns:
+        True if the domain exists in the taxonomy, False otherwise
+    
+    Raises:
+        FileNotFoundError: If the taxonomy file cannot be found
+        ValueError: If the taxonomy file is invalid JSON
+    """
+    domains_data = _load_domains()
+    domains = domains_data.get("domains", {})
+    return slug in domains
+

agent0_sdk/core/sdk.py

@@ -278,7 +278,12 @@ class SDK:
         return Agent(sdk=self, registration_file=registration_file)
 
     def loadAgent(self, agentId: AgentId) -> Agent:
-        """Load an existing agent (hydrates from registration file if registered)."""
+        """Load an existing agent (hydrates from registration file if registered).
+        
+        Note: Agents can be minted with an empty token URI (e.g. IPFS flow where publish fails).
+        In that case we return a partially-hydrated Agent with an empty registration file so the
+        caller can resume publishing and set the URI later.
+        """
         # Convert agentId to string if it's an integer
         agentId = str(agentId)
         
@@ -292,16 +297,22 @@ class SDK:
         
         # Get token URI from contract
         try:
-            token_uri = self.web3_client.call_contract(
-                self.identity_registry, "tokenURI", int(token_id)
+            agent_uri = self.web3_client.call_contract(
+                self.identity_registry, "tokenURI", int(token_id)  # tokenURI is ERC-721 standard, but represents agentURI
             )
         except Exception as e:
             raise ValueError(f"Failed to load agent {agentId}: {e}")
         
-        # Load registration file
-        registration_file = self._load_registration_file(token_uri)
+        # Load registration file (or fall back to a minimal file if agent URI is missing)
+        registration_file = self._load_registration_file(agent_uri)
         registration_file.agentId = agentId
-        registration_file.agentURI = token_uri if token_uri else None
+        registration_file.agentURI = agent_uri if agent_uri else None
+
+        if not agent_uri or not str(agent_uri).strip():
+            logger.warning(
+                f"Agent {agentId} has no agentURI set on-chain yet. "
+                "Returning a partial agent; update info and call registerIPFS() to publish and set URI."
+            )
         
         # Store registry address for proper JSON generation
         registry_address = self._registries.get("IDENTITY")
@@ -315,7 +326,13 @@ class SDK:
         return Agent(sdk=self, registration_file=registration_file)
 
     def _load_registration_file(self, uri: str) -> RegistrationFile:
-        """Load registration file from URI."""
+        """Load registration file from URI.
+        
+        If uri is empty/None/whitespace, returns an empty RegistrationFile to allow resume flows.
+        """
+        if not uri or not str(uri).strip():
+            return RegistrationFile()
+
         if uri.startswith("ipfs://"):
             if not self.ipfs_client:
                 raise ValueError("IPFS client not configured")
@@ -346,21 +363,20 @@ class SDK:
         # For now, we'll leave it empty
         registration_file.operators = []
         
-        # Hydrate metadata from on-chain (agentWallet, agentName, custom metadata)
+        # Hydrate agentWallet from on-chain (now uses getAgentWallet() instead of metadata)
         agent_id = token_id
         try:
-            # Try to get agentWallet from on-chain metadata
-            wallet_bytes = self.web3_client.call_contract(
-                self.identity_registry, "getMetadata", agent_id, "agentWallet"
+            # Get agentWallet using the new dedicated function
+            wallet_address = self.web3_client.call_contract(
+                self.identity_registry, "getAgentWallet", agent_id
             )
-            if wallet_bytes and len(wallet_bytes) > 0:
-                wallet_address = "0x" + wallet_bytes.hex()
+            if wallet_address and wallet_address != "0x0000000000000000000000000000000000000000":
                 registration_file.walletAddress = wallet_address
                 # If wallet is read from on-chain, use current chain ID
                 # (the chain ID from the registration file might be outdated)
                 registration_file.walletChainId = self.chainId
         except Exception as e:
-            # No on-chain wallet, will fall back to registration file
+            # No on-chain wallet set, will fall back to registration file
             pass
         
         try:
@@ -904,11 +920,10 @@ class SDK:
         agentId: "AgentId",
         feedbackFile: Dict[str, Any],
         idem: Optional["IdemKey"] = None,
-        feedbackAuth: Optional[bytes] = None,
     ) -> "Feedback":
         """Give feedback (maps 8004 endpoint)."""
         return self.feedback_manager.giveFeedback(
-            agentId, feedbackFile, idem, feedbackAuth
+            agentId, feedbackFile, idem
         )
     
     def getFeedback(

agent0_sdk/core/subgraph_client.py

@@ -30,25 +30,38 @@ class SubgraphClient:
         Returns:
             JSON response from the subgraph
         """
-        try:
+        def _do_query(q: str) -> Dict[str, Any]:
             response = requests.post(
                 self.subgraph_url,
-                json={
-                    'query': query,
-                    'variables': variables or {}
-                },
+                json={'query': q, 'variables': variables or {}},
                 headers={'Content-Type': 'application/json'},
-                timeout=10
+                timeout=10,
             )
             response.raise_for_status()
             result = response.json()
-            
-            # Check for GraphQL errors
             if 'errors' in result:
                 error_messages = [err.get('message', 'Unknown error') for err in result['errors']]
                 raise ValueError(f"GraphQL errors: {', '.join(error_messages)}")
-            
             return result.get('data', {})
+
+        try:
+            return _do_query(query)
+        except ValueError as e:
+            # Backwards/forwards compatibility for hosted subgraphs:
+            # Some deployments still expose `responseUri` instead of `responseURI`.
+            msg = str(e)
+            if ("has no field" in msg and "responseURI" in msg) and ("responseURI" in query):
+                logger.debug("Subgraph schema missing responseURI; retrying query with responseUri")
+                return _do_query(query.replace("responseURI", "responseUri"))
+            # Some deployments don't expose agentWallet fields on AgentRegistrationFile.
+            if (
+                "Type `AgentRegistrationFile` has no field `agentWallet`" in msg
+                or "Type `AgentRegistrationFile` has no field `agentWalletChainId`" in msg
+            ):
+                logger.debug("Subgraph schema missing agentWallet fields; retrying query without them")
+                q2 = query.replace("agentWalletChainId", "").replace("agentWallet", "")
+                return _do_query(q2)
+            raise
         except requests.exceptions.RequestException as e:
             raise ConnectionError(f"Failed to query subgraph: {e}")
 
@@ -248,10 +261,12 @@ class SubgraphClient:
                 ) {{
                     id
                     score
+                    feedbackIndex
                     tag1
                     tag2
+                    endpoint
                     clientAddress
-                    feedbackUri
+                    feedbackURI
                     feedbackURIType
                     feedbackHash
                     isRevoked
@@ -276,7 +291,7 @@ class SubgraphClient:
                     responses {{
                         id
                         responder
-                        responseUri
+                        responseURI
                         responseHash
                         createdAt
                     }}
@@ -400,10 +415,12 @@ class SubgraphClient:
                 id
                 agent { id agentId chainId }
                 clientAddress
+                feedbackIndex
                 score
                 tag1
                 tag2
-                feedbackUri
+                endpoint
+                feedbackURI
                 feedbackURIType
                 feedbackHash
                 isRevoked
@@ -429,7 +446,7 @@ class SubgraphClient:
                 responses {
                     id
                     responder
-                    responseUri
+                    responseURI
                     responseHash
                     createdAt
                 }
@@ -548,10 +565,12 @@ class SubgraphClient:
                 id
                 agent {{ id agentId chainId }}
                 clientAddress
+                feedbackIndex
                 score
                 tag1
                 tag2
-                feedbackUri
+                endpoint
+                feedbackURI
                 feedbackURIType
                 feedbackHash
                 isRevoked
@@ -577,7 +596,7 @@ class SubgraphClient:
                 responses {{
                     id
                     responder
-                    responseUri
+                    responseURI
                     responseHash
                     createdAt
                 }}

agent0_sdk/core/web3_client.py

@@ -5,7 +5,7 @@ Web3 integration layer for smart contract interactions.
 from __future__ import annotations
 
 import json
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple, Union, Callable
 
 try:
     from web3 import Web3
@@ -123,22 +123,6 @@ class Web3Client:
         
         return event_filter.get_all_entries()
 
-    def encodeFeedbackAuth(
-        self,
-        agentId: int,
-        clientAddress: str,
-        indexLimit: int,
-        expiry: int,
-        chainId: int,
-        identityRegistry: str,
-        signerAddress: str
-    ) -> bytes:
-        """Encode feedback authorization data."""
-        return self.w3.codec.encode(
-            ['uint256', 'address', 'uint64', 'uint256', 'uint256', 'address', 'address'],
-            [agentId, clientAddress, indexLimit, expiry, chainId, identityRegistry, signerAddress]
-        )
-
     def signMessage(self, message: bytes) -> bytes:
         """Sign a message with the account's private key."""
         # Create a SignableMessage from the raw bytes
@@ -190,3 +174,186 @@ class Web3Client:
     def get_transaction_count(self, address: str) -> int:
         """Get transaction count (nonce) of an address."""
         return self.w3.eth.get_transaction_count(address)
+
+    def encodeEIP712Domain(
+        self,
+        name: str,
+        version: str,
+        chain_id: int,
+        verifying_contract: str
+    ) -> Dict[str, Any]:
+        """Encode EIP-712 domain separator.
+        
+        Args:
+            name: Contract name
+            version: Contract version
+            chain_id: Chain ID
+            verifying_contract: Contract address
+            
+        Returns:
+            Domain separator dictionary
+        """
+        return {
+            "name": name,
+            "version": version,
+            "chainId": chain_id,
+            "verifyingContract": verifying_contract
+        }
+
+    def build_agent_wallet_set_typed_data(
+        self,
+        agent_id: int,
+        new_wallet: str,
+        owner: str,
+        deadline: int,
+        verifying_contract: str,
+        chain_id: int,
+    ) -> Dict[str, Any]:
+        """Build EIP-712 typed data for ERC-8004 IdentityRegistry setAgentWallet.
+
+        Contract expects:
+        - domain: name="ERC8004IdentityRegistry", version="1"
+        - primaryType: "AgentWalletSet"
+        - message: { agentId, newWallet, owner, deadline }
+        """
+        domain = self.encodeEIP712Domain(
+            name="ERC8004IdentityRegistry",
+            version="1",
+            chain_id=chain_id,
+            verifying_contract=verifying_contract,
+        )
+
+        message_types = {
+            "AgentWalletSet": [
+                {"name": "agentId", "type": "uint256"},
+                {"name": "newWallet", "type": "address"},
+                {"name": "owner", "type": "address"},
+                {"name": "deadline", "type": "uint256"},
+            ]
+        }
+
+        message = {
+            "agentId": agent_id,
+            "newWallet": new_wallet,
+            "owner": owner,
+            "deadline": deadline,
+        }
+
+        # eth_account.messages.encode_typed_data expects the "full_message" format
+        return {
+            "types": {
+                "EIP712Domain": [
+                    {"name": "name", "type": "string"},
+                    {"name": "version", "type": "string"},
+                    {"name": "chainId", "type": "uint256"},
+                    {"name": "verifyingContract", "type": "address"},
+                ],
+                **message_types,
+            },
+            "domain": domain,
+            "primaryType": "AgentWalletSet",
+            "message": message,
+        }
+
+    def sign_typed_data(
+        self,
+        full_message: Dict[str, Any],
+        signer: Union[str, BaseAccount],
+    ) -> bytes:
+        """Sign EIP-712 typed data with a provided signer (EOA).
+
+        Args:
+            full_message: Typed data dict compatible with encode_typed_data(full_message=...)
+            signer: Private key string or eth_account BaseAccount/LocalAccount
+
+        Returns:
+            Signature bytes
+        """
+        from eth_account.messages import encode_typed_data
+
+        if isinstance(signer, str):
+            acct: BaseAccount = Account.from_key(signer)
+        else:
+            acct = signer
+
+        encoded = encode_typed_data(full_message=full_message)
+        signed = acct.sign_message(encoded)
+        return signed.signature
+
+    def signEIP712Message(
+        self,
+        domain: Dict[str, Any],
+        message_types: Dict[str, List[Dict[str, str]]],
+        message: Dict[str, Any]
+    ) -> bytes:
+        """Sign an EIP-712 typed message.
+        
+        Args:
+            domain: EIP-712 domain separator
+            message_types: Type definitions for the message
+            message: Message data to sign
+            
+        Returns:
+            Signature bytes
+        """
+        if not self.account:
+            raise ValueError("Cannot sign message: SDK is in read-only mode. Provide a signer to enable signing.")
+        
+        from eth_account.messages import encode_typed_data
+        
+        structured_data = {
+            "types": {
+                "EIP712Domain": [
+                    {"name": "name", "type": "string"},
+                    {"name": "version", "type": "string"},
+                    {"name": "chainId", "type": "uint256"},
+                    {"name": "verifyingContract", "type": "address"}
+                ],
+                **message_types
+            },
+            "domain": domain,
+            "primaryType": list(message_types.keys())[0] if message_types else "Message",
+            "message": message
+        }
+        
+        encoded = encode_typed_data(full_message=structured_data)
+        signed = self.account.sign_message(encoded)
+        return signed.signature
+
+    def verifyEIP712Signature(
+        self,
+        domain: Dict[str, Any],
+        message_types: Dict[str, List[Dict[str, str]]],
+        message: Dict[str, Any],
+        signature: bytes
+    ) -> str:
+        """Verify an EIP-712 signature and recover the signer address.
+        
+        Args:
+            domain: EIP-712 domain separator
+            message_types: Type definitions for the message
+            message: Message data that was signed
+            signature: Signature bytes to verify
+            
+        Returns:
+            Recovered signer address
+        """
+        from eth_account.messages import encode_typed_data
+        
+        structured_data = {
+            "types": {
+                "EIP712Domain": [
+                    {"name": "name", "type": "string"},
+                    {"name": "version", "type": "string"},
+                    {"name": "chainId", "type": "uint256"},
+                    {"name": "verifyingContract", "type": "address"}
+                ],
+                **message_types
+            },
+            "domain": domain,
+            "primaryType": list(message_types.keys())[0] if message_types else "Message",
+            "message": message
+        }
+        
+        encoded = encode_typed_data(full_message=structured_data)
+        return self.w3.eth.account.recover_message(encoded, signature=signature)