intentkit 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

intentkit/skills/defillama/tvl/fetch_chains.py

@@ -0,0 +1,107 @@
+"""Tool for fetching chain TVL data via DeFi Llama API."""
+
+from typing import List, Optional, Type
+
+from langchain.schema.runnable import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.defillama.api import fetch_chains
+from intentkit.skills.defillama.base import DefiLlamaBaseTool
+
+FETCH_CHAINS_PROMPT = """
+This tool fetches current Total Value Locked (TVL) data for all blockchains tracked by DeFi Llama.
+No input parameters are required. Returns a comprehensive list including:
+- Chain name and identifiers
+- Current TVL in USD
+- Chain metadata (token symbol, IDs)
+- Aggregated total TVL across all chains
+Returns the complete list of chains and total TVL or an error if the request fails.
+"""
+
+
+class ChainTVLData(BaseModel):
+    """Model representing TVL data for a single chain."""
+
+    name: str = Field(..., description="Chain name")
+    tvl: float = Field(..., description="Total Value Locked in USD")
+    gecko_id: Optional[str] = Field(None, description="CoinGecko identifier")
+    token_symbol: Optional[str] = Field(
+        None, alias="tokenSymbol", description="Native token symbol"
+    )
+    cmc_id: Optional[str] = Field(
+        None, alias="cmcId", description="CoinMarketCap identifier"
+    )
+    chain_id: Optional[int | str] = Field(
+        None, alias="chainId", description="Chain identifier"
+    )
+
+
+class FetchChainsInput(BaseModel):
+    """Input schema for fetching all chains' TVL data.
+
+    This endpoint doesn't require any parameters as it returns
+    TVL data for all chains.
+    """
+
+    pass
+
+
+class FetchChainsResponse(BaseModel):
+    """Response schema for all chains' TVL data."""
+
+    chains: List[ChainTVLData] = Field(
+        default_factory=list, description="List of chains with their TVL data"
+    )
+    total_tvl: float = Field(..., description="Total TVL across all chains in USD")
+    error: Optional[str] = Field(None, description="Error message if any")
+
+
+class DefiLlamaFetchChains(DefiLlamaBaseTool):
+    """Tool for fetching current TVL data for all blockchains.
+
+    This tool retrieves the current Total Value Locked (TVL) for all chains
+    tracked by DeFi Llama, including chain identifiers and metadata.
+
+    Example:
+        chains_tool = DefiLlamaFetchChains(
+            skill_store=store,
+            agent_id="agent_123",
+            agent_store=agent_store
+        )
+        result = await chains_tool._arun()
+    """
+
+    name: str = "defillama_fetch_chains"
+    description: str = FETCH_CHAINS_PROMPT
+    args_schema: Type[BaseModel] = FetchChainsInput
+
+    async def _arun(self, config: RunnableConfig) -> FetchChainsResponse:
+        """Fetch TVL data for all chains.
+
+        Returns:
+            FetchChainsResponse containing chain TVL data and total TVL or error
+        """
+        try:
+            # Check rate limiting
+            context = self.context_from_config(config)
+            is_rate_limited, error_msg = await self.check_rate_limit(context)
+            if is_rate_limited:
+                return FetchChainsResponse(chains=[], total_tvl=0, error=error_msg)
+
+            # Fetch chains data from API
+            result = await fetch_chains()
+
+            # Check for API errors
+            if isinstance(result, dict) and "error" in result:
+                return FetchChainsResponse(
+                    chains=[], total_tvl=0, error=result["error"]
+                )
+
+            # Parse chains data and calculate total TVL
+            chains = [ChainTVLData(**chain_data) for chain_data in result]
+            total_tvl = sum(chain.tvl for chain in chains)
+
+            return FetchChainsResponse(chains=chains, total_tvl=total_tvl)
+
+        except Exception as e:
+            return FetchChainsResponse(chains=[], total_tvl=0, error=str(e))

intentkit/skills/defillama/tvl/fetch_historical_tvl.py

@@ -0,0 +1,91 @@
+"""Tool for fetching total historical TVL via DeFiLlama API."""
+
+from typing import List, Type
+
+from langchain.schema.runnable import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.defillama.api import fetch_historical_tvl
+from intentkit.skills.defillama.base import DefiLlamaBaseTool
+
+FETCH_TOTAL_HISTORICAL_TVL_PROMPT = """
+This tool fetches historical Total Value Locked (TVL) data across all blockchains.
+Returns a time series of aggregate TVL values with their corresponding dates.
+No input parameters are required as this endpoint returns global DeFi TVL data.
+"""
+
+
+class HistoricalTVLDataPoint(BaseModel):
+    """Model representing a single TVL data point."""
+
+    date: int = Field(..., description="Unix timestamp of the TVL measurement")
+    tvl: float = Field(..., description="Total Value Locked in USD at this timestamp")
+
+
+class FetchHistoricalTVLInput(BaseModel):
+    """Input schema for fetching historical TVL data.
+
+    This endpoint doesn't require any parameters as it returns
+    global TVL data across all chains.
+    """
+
+    pass
+
+
+class FetchHistoricalTVLResponse(BaseModel):
+    """Response schema for historical TVL data."""
+
+    data: List[HistoricalTVLDataPoint] = Field(
+        default_factory=list,
+        description="List of historical TVL data points across all chains",
+    )
+    error: str | None = Field(default=None, description="Error message if any")
+
+
+class DefiLlamaFetchHistoricalTvl(DefiLlamaBaseTool):
+    """Tool for fetching historical TVL data across all blockchains.
+
+    This tool fetches the complete Total Value Locked (TVL) history aggregated
+    across all chains using the DeFiLlama API. It includes rate limiting to
+    ensure reliable data retrieval.
+
+    Example:
+        tvl_tool = DefiLlamaFetchHistoricalTvl(
+            skill_store=store,
+            agent_id="agent_123",
+            agent_store=agent_store
+        )
+        result = await tvl_tool._arun()
+    """
+
+    name: str = "defillama_fetch_total_historical_tvl"
+    description: str = FETCH_TOTAL_HISTORICAL_TVL_PROMPT
+    args_schema: Type[BaseModel] = FetchHistoricalTVLInput
+
+    async def _arun(self, config: RunnableConfig) -> FetchHistoricalTVLResponse:
+        """Fetch historical TVL data across all chains.
+
+        Returns:
+            FetchHistoricalTVLResponse containing TVL history or error
+        """
+        try:
+            # Check rate limiting
+            context = self.context_from_config(config)
+            is_rate_limited, error_msg = await self.check_rate_limit(context)
+            if is_rate_limited:
+                return FetchHistoricalTVLResponse(error=error_msg)
+
+            # Fetch TVL history from API
+            result = await fetch_historical_tvl()
+
+            # Check for API errors
+            if isinstance(result, dict) and "error" in result:
+                return FetchHistoricalTVLResponse(error=result["error"])
+
+            # Parse response into our schema
+            data_points = [HistoricalTVLDataPoint(**point) for point in result]
+
+            return FetchHistoricalTVLResponse(data=data_points)
+
+        except Exception as e:
+            return FetchHistoricalTVLResponse(error=str(e))

intentkit/skills/defillama/tvl/fetch_protocol.py

@@ -0,0 +1,207 @@
+"""Tool for fetching specific protocol details via DeFi Llama API."""
+
+from typing import Dict, List, Optional, Type
+
+from langchain.schema.runnable import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.defillama.api import fetch_protocol
+from intentkit.skills.defillama.base import DefiLlamaBaseTool
+
+FETCH_PROTOCOL_PROMPT = """
+This tool fetches comprehensive details about a specific DeFi protocol.
+Provide the protocol identifier (e.g., "aave", "curve") to get detailed information including:
+- Basic protocol information (name, description, website)
+- TVL data across different chains
+- Token information and historical amounts
+- Social media and development links
+- Funding history and significant events
+- Market metrics and related protocols
+Returns complete protocol details or an error if the protocol is not found.
+"""
+
+
+class TokenAmount(BaseModel):
+    """Model representing token amounts at a specific date."""
+
+    date: int = Field(..., description="Unix timestamp")
+    tokens: Dict[str, float] = Field(..., description="Token amounts keyed by symbol")
+
+
+class ChainTVLData(BaseModel):
+    """Model representing TVL data for a specific chain."""
+
+    tvl: List[Dict[str, float]] = Field(..., description="Historical TVL data points")
+    tokens: Optional[Dict[str, float]] = Field(
+        None, description="Current token amounts"
+    )
+    tokensInUsd: Optional[Dict[str, float]] = Field(
+        None, description="Current token amounts in USD"
+    )
+
+
+class HistoricalTVL(BaseModel):
+    """Model representing a historical TVL data point."""
+
+    date: int = Field(..., description="Unix timestamp")
+    totalLiquidityUSD: float = Field(..., description="Total TVL in USD")
+
+
+class Raise(BaseModel):
+    """Model representing a funding round."""
+
+    date: int = Field(..., description="Funding date")
+    name: str = Field(..., description="Protocol name")
+    round: str = Field(..., description="Funding round type")
+    amount: float = Field(..., description="Amount raised in millions")
+    chains: List[str] = Field(..., description="Chains involved")
+    sector: str = Field(..., description="Business sector")
+    category: str = Field(..., description="Protocol category")
+    categoryGroup: str = Field(..., description="Category group")
+    source: str = Field(..., description="Information source")
+    leadInvestors: List[str] = Field(default_factory=list, description="Lead investors")
+    otherInvestors: List[str] = Field(
+        default_factory=list, description="Other investors"
+    )
+    valuation: Optional[float] = Field(None, description="Valuation at time of raise")
+    defillamaId: Optional[str] = Field(None, description="DefiLlama ID")
+
+
+class Hallmark(BaseModel):
+    """Model representing a significant protocol event."""
+
+    timestamp: int
+    description: str
+
+
+class ProtocolDetail(BaseModel):
+    """Model representing detailed protocol information."""
+
+    # Basic Info
+    id: str = Field(..., description="Protocol unique identifier")
+    name: str = Field(..., description="Protocol name")
+    address: Optional[str] = Field(None, description="Protocol address")
+    symbol: str = Field(..., description="Protocol token symbol")
+    url: str = Field(..., description="Protocol website")
+    description: str = Field(..., description="Protocol description")
+    logo: str = Field(..., description="Logo URL")
+
+    # Chain Info
+    chains: List[str] = Field(default_factory=list, description="Supported chains")
+    currentChainTvls: Dict[str, float] = Field(..., description="Current TVL by chain")
+    chainTvls: Dict[str, ChainTVLData] = Field(
+        ..., description="Historical TVL data by chain"
+    )
+
+    # Identifiers
+    gecko_id: Optional[str] = Field(None, description="CoinGecko ID")
+    cmcId: Optional[str] = Field(None, description="CoinMarketCap ID")
+
+    # Social & Development
+    twitter: Optional[str] = Field(None, description="Twitter handle")
+    treasury: Optional[str] = Field(None, description="Treasury information")
+    governanceID: Optional[List[str]] = Field(
+        None, description="Governance identifiers"
+    )
+    github: Optional[List[str]] = Field(None, description="GitHub repositories")
+
+    # Protocol Relationships
+    isParentProtocol: Optional[bool] = Field(
+        None, description="Whether this is a parent protocol"
+    )
+    otherProtocols: Optional[List[str]] = Field(None, description="Related protocols")
+
+    # Historical Data
+    tokens: List[TokenAmount] = Field(
+        default_factory=list, description="Historical token amounts"
+    )
+    tvl: List[HistoricalTVL] = Field(..., description="Historical TVL data points")
+    raises: Optional[List[Raise]] = Field(None, description="Funding rounds")
+    hallmarks: Optional[List[Hallmark]] = Field(None, description="Significant events")
+
+    # Market Data
+    mcap: Optional[float] = Field(None, description="Market capitalization")
+    metrics: Dict = Field(default_factory=dict, description="Additional metrics")
+
+
+class DefiLlamaProtocolInput(BaseModel):
+    """Input model for fetching protocol details."""
+
+    protocol: str = Field(..., description="Protocol identifier to fetch")
+
+
+class DefiLlamaProtocolOutput(BaseModel):
+    """Output model for the protocol fetching tool."""
+
+    protocol: Optional[ProtocolDetail] = Field(None, description="Protocol details")
+    error: Optional[str] = Field(None, description="Error message if any")
+
+
+class DefiLlamaFetchProtocol(DefiLlamaBaseTool):
+    """Tool for fetching detailed protocol information from DeFi Llama.
+
+    This tool retrieves comprehensive information about a specific protocol,
+    including TVL history, token breakdowns, and metadata.
+
+    Example:
+        protocol_tool = DefiLlamaFetchProtocol(
+            skill_store=store,
+            agent_id="agent_123",
+            agent_store=agent_store
+        )
+        result = await protocol_tool._arun(protocol="aave")
+    """
+
+    name: str = "defillama_fetch_protocol"
+    description: str = FETCH_PROTOCOL_PROMPT
+    args_schema: Type[BaseModel] = DefiLlamaProtocolInput
+
+    async def _arun(
+        self, config: RunnableConfig, protocol: str
+    ) -> DefiLlamaProtocolOutput:
+        """Fetch detailed information about a specific protocol.
+
+        Args:
+            config: Runnable configuration
+            protocol: Protocol identifier to fetch
+
+        Returns:
+            DefiLlamaProtocolOutput containing protocol details or error
+        """
+        try:
+            # Check rate limiting
+            context = self.context_from_config(config)
+            is_rate_limited, error_msg = await self.check_rate_limit(context)
+            if is_rate_limited:
+                return DefiLlamaProtocolOutput(error=error_msg)
+
+            # Fetch protocol data from API
+            result = await fetch_protocol(protocol)
+
+            if isinstance(result, dict) and "error" in result:
+                return DefiLlamaProtocolOutput(error=result["error"])
+
+            # Process hallmarks if present
+            hallmarks = None
+            if "hallmarks" in result:
+                hallmarks = [
+                    Hallmark(timestamp=h[0], description=h[1])
+                    for h in result.get("hallmarks", [])
+                ]
+
+            # Create raises objects if present
+            raises = None
+            if "raises" in result:
+                raises = [Raise(**r) for r in result.get("raises", [])]
+
+            # Create protocol detail object
+            protocol_detail = ProtocolDetail(
+                **{k: v for k, v in result.items() if k not in ["hallmarks", "raises"]},
+                hallmarks=hallmarks,
+                raises=raises,
+            )
+
+            return DefiLlamaProtocolOutput(protocol=protocol_detail)
+
+        except Exception as e:
+            return DefiLlamaProtocolOutput(error=str(e))

intentkit/skills/defillama/tvl/fetch_protocol_current_tvl.py

@@ -0,0 +1,93 @@
+"""Tool for fetching protocol TVL via DeFiLlama API."""
+
+from typing import Type
+
+from langchain.schema.runnable import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.defillama.api import fetch_protocol_current_tvl
+from intentkit.skills.defillama.base import DefiLlamaBaseTool
+
+FETCH_TVL_PROMPT = """
+This tool fetches the current Total Value Locked (TVL) for a specific DeFi protocol.
+Provide the protocol slug (e.g., "aave", "curve") to get its current TVL in USD.
+Returns the normalized protocol name and its TVL value.
+"""
+
+
+class FetchProtocolCurrentTVLInput(BaseModel):
+    """Input schema for fetching current protocol TVL."""
+
+    protocol: str = Field(
+        ..., description="Protocol slug to fetch TVL for (e.g., 'aave', 'curve')"
+    )
+
+
+class FetchProtocolCurrentTVLResponse(BaseModel):
+    """Response schema for current protocol TVL."""
+
+    protocol: str = Field(..., description="Normalized protocol slug")
+    tvl: float = Field(..., description="Current Total Value Locked in USD")
+    error: str | None = Field(default=None, description="Error message if any")
+
+
+class DefiLlamaFetchProtocolCurrentTvl(DefiLlamaBaseTool):
+    """Tool for fetching current TVL of a specific DeFi protocol.
+
+    This tool fetches the current Total Value Locked (TVL) for a given protocol
+    using the DeFiLlama API. It includes rate limiting to avoid API abuse.
+
+    Example:
+        tvl_tool = DefiLlamaFetchProtocolCurrentTvl(
+            skill_store=store,
+            agent_id="agent_123",
+            agent_store=agent_store
+        )
+        result = await tvl_tool._arun(protocol="aave")
+    """
+
+    name: str = "defillama_fetch_protocol_tvl"
+    description: str = FETCH_TVL_PROMPT
+    args_schema: Type[BaseModel] = FetchProtocolCurrentTVLInput
+
+    async def _arun(
+        self, config: RunnableConfig, protocol: str
+    ) -> FetchProtocolCurrentTVLResponse:
+        """Fetch current TVL for the given protocol.
+
+        Args:
+            config: Runnable configuration
+            protocol: DeFi protocol slug (e.g., "aave", "curve")
+
+        Returns:
+            FetchProtocolCurrentTVLResponse containing protocol name, TVL value or error
+        """
+        try:
+            # Check rate limiting
+            context = self.context_from_config(config)
+            is_rate_limited, error_msg = await self.check_rate_limit(context)
+            if is_rate_limited:
+                return FetchProtocolCurrentTVLResponse(
+                    protocol=protocol, tvl=0, error=error_msg
+                )
+
+            # Normalize protocol slug
+            normalized_protocol = protocol.lower().replace(" ", "-")
+
+            # Fetch TVL from API
+            result = await fetch_protocol_current_tvl(normalized_protocol)
+
+            # Check for API errors
+            if isinstance(result, dict) and "error" in result:
+                return FetchProtocolCurrentTVLResponse(
+                    protocol=normalized_protocol, tvl=0, error=result["error"]
+                )
+
+            return FetchProtocolCurrentTVLResponse(
+                protocol=normalized_protocol, tvl=float(result)
+            )
+
+        except Exception as e:
+            return FetchProtocolCurrentTVLResponse(
+                protocol=protocol, tvl=0, error=str(e)
+            )

intentkit/skills/defillama/tvl/fetch_protocols.py

@@ -0,0 +1,196 @@
+"""Tool for fetching all protocols via DeFi Llama API."""
+
+from typing import Dict, List, Optional, Type, Union
+
+from langchain.schema.runnable import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.defillama.api import fetch_protocols
+from intentkit.skills.defillama.base import DefiLlamaBaseTool
+
+FETCH_PROTOCOLS_PROMPT = """
+This tool fetches information about all protocols tracked by DeFi Llama.
+No input parameters are required. Returns comprehensive data for each protocol including:
+- Basic information (name, description, website, logo)
+- TVL metrics (total and per-chain breakdowns)
+- Audit status and security information
+- Token details and market metrics
+- Chain support and deployment information
+- Social media and development links
+- Protocol relationships (forks, oracles)
+- Historical events and significant updates
+Returns the complete list of protocols or an error if the request fails.
+"""
+
+
+class Hallmark(BaseModel):
+    """Model representing a protocol hallmark (significant event)."""
+
+    timestamp: int
+    description: str
+
+
+class Protocol(BaseModel):
+    """Model representing a DeFi protocol."""
+
+    # Basic Info
+    id: str = Field(..., description="Protocol unique identifier")
+    name: str = Field(..., description="Protocol name")
+    address: Optional[str] = Field(None, description="Protocol's main contract address")
+    symbol: str = Field(..., description="Protocol token symbol")
+    url: Optional[str] = Field(None, description="Protocol website")
+    description: Optional[str] = Field(None, description="Protocol description")
+    chain: Optional[str] = Field(None, description="Main chain of the protocol")
+    logo: Optional[str] = Field(None, description="URL to protocol logo")
+
+    # Audit Information
+    audits: Union[str, int] = Field("0", description="Number of audits")
+    audit_note: Optional[str] = Field(None, description="Additional audit information")
+    audit_links: Optional[List[str]] = Field(None, description="Links to audit reports")
+
+    # External IDs
+    gecko_id: Optional[str] = Field(None, description="CoinGecko ID")
+    cmcId: Optional[Union[str, int]] = Field(None, description="CoinMarketCap ID")
+
+    # Classification
+    category: str = Field(..., description="Protocol category")
+    chains: List[str] = Field(
+        default_factory=list, description="Chains the protocol operates on"
+    )
+
+    # Module and Related Info
+    module: str = Field(..., description="Module name in DefiLlama")
+    parentProtocol: Optional[str] = Field(
+        None, description="Parent protocol identifier"
+    )
+
+    # Social and Development
+    twitter: Optional[str] = Field(None, description="Twitter handle")
+    github: Optional[List[str]] = Field(None, description="GitHub organization names")
+
+    # Protocol Relationships
+    oracles: List[str] = Field(default_factory=list, description="Oracle services used")
+    forkedFrom: List[str] = Field(
+        default_factory=list, description="Protocols this one was forked from"
+    )
+
+    # Additional Metadata
+    methodology: Optional[str] = Field(None, description="TVL calculation methodology")
+    listedAt: Optional[int] = Field(
+        None, description="Timestamp when protocol was listed"
+    )
+    openSource: Optional[bool] = Field(
+        None, description="Whether protocol is open source"
+    )
+    treasury: Optional[str] = Field(None, description="Treasury information")
+    misrepresentedTokens: Optional[bool] = Field(
+        None, description="Whether tokens are misrepresented"
+    )
+    hallmarks: Optional[List[Hallmark]] = Field(
+        None, description="Significant protocol events"
+    )
+
+    # TVL Related Data
+    tvl: Optional[float] = Field(None, description="Total Value Locked in USD")
+    chainTvls: Dict[str, float] = Field(
+        default_factory=dict,
+        description="TVL breakdown by chain including special types (staking, borrowed, etc.)",
+    )
+    change_1h: Optional[float] = Field(None, description="1 hour TVL change percentage")
+    change_1d: Optional[float] = Field(None, description="1 day TVL change percentage")
+    change_7d: Optional[float] = Field(None, description="7 day TVL change percentage")
+
+    # Additional TVL Components
+    staking: Optional[float] = Field(None, description="Value in staking")
+    pool2: Optional[float] = Field(None, description="Value in pool2")
+    borrowed: Optional[float] = Field(None, description="Value borrowed")
+
+    # Token Information
+    tokenBreakdowns: Dict[str, float] = Field(
+        default_factory=dict, description="TVL breakdown by token"
+    )
+    mcap: Optional[float] = Field(None, description="Market capitalization")
+
+
+class DefiLlamaProtocolsOutput(BaseModel):
+    """Output model for the protocols fetching tool."""
+
+    protocols: List[Protocol] = Field(
+        default_factory=list, description="List of fetched protocols"
+    )
+    error: Optional[str] = Field(None, description="Error message if any")
+
+
+class DefiLlamaFetchProtocols(DefiLlamaBaseTool):
+    """Tool for fetching all protocols from DeFi Llama.
+
+    This tool retrieves information about all protocols tracked by DeFi Llama,
+    including their TVL, supported chains, and related metrics.
+
+    Example:
+        protocols_tool = DefiLlamaFetchProtocols(
+            skill_store=store,
+            agent_id="agent_123",
+            agent_store=agent_store
+        )
+        result = await protocols_tool._arun()
+    """
+
+    name: str = "defillama_fetch_protocols"
+    description: str = FETCH_PROTOCOLS_PROMPT
+
+    class EmptyArgsSchema(BaseModel):
+        """Empty schema for no input parameters."""
+
+        pass
+
+    args_schema: Type[BaseModel] = EmptyArgsSchema
+
+    async def _arun(self, config: RunnableConfig) -> DefiLlamaProtocolsOutput:
+        """Fetch information about all protocols.
+
+        Returns:
+            DefiLlamaProtocolsOutput containing list of protocols or error
+        """
+        try:
+            # Check rate limiting
+            context = self.context_from_config(config)
+            is_rate_limited, error_msg = await self.check_rate_limit(context)
+            if is_rate_limited:
+                return DefiLlamaProtocolsOutput(error=error_msg)
+
+            # Fetch protocols from API
+            result = await fetch_protocols()
+
+            if isinstance(result, dict) and "error" in result:
+                return DefiLlamaProtocolsOutput(error=result["error"])
+
+            # Convert raw data to Protocol models
+            protocols = []
+            for protocol_data in result:
+                try:
+                    # Process hallmarks if present
+                    hallmarks = None
+                    if "hallmarks" in protocol_data and protocol_data["hallmarks"]:
+                        hallmarks = [
+                            Hallmark(timestamp=h[0], description=h[1])
+                            for h in protocol_data["hallmarks"]
+                        ]
+
+                    # Create protocol model
+                    protocol = Protocol(
+                        **{k: v for k, v in protocol_data.items() if k != "hallmarks"},
+                        hallmarks=hallmarks,
+                    )
+                    protocols.append(protocol)
+                except Exception as e:
+                    # Log error for individual protocol processing but continue with others
+                    print(
+                        f"Error processing protocol {protocol_data.get('name', 'unknown')}: {str(e)}"
+                    )
+                    continue
+
+            return DefiLlamaProtocolsOutput(protocols=protocols)
+
+        except Exception as e:
+            return DefiLlamaProtocolsOutput(error=str(e))