1"""
2CoinGecko Tool Wrappers
3 
4Wraps tools from /tools/coingecko/ for use in Agent framework.
5Provides price data, charts, market discovery, global stats, derivatives,
6exchanges, NFTs, infrastructure, search, and contract lookups.
7"""
8import asyncio
9import logging
10from typing import List, Optional
11 
12from core.tool import BaseTool, ToolContext, ToolResult
13 
14logger = logging.getLogger(__name__)
15 
16# Import original tools from local tools directory
17try:
18    from .tools.coin_prices import get_coin_prices_at_timestamps
19    from .tools.coin_ohlc_range_by_id import get_coin_ohlc_range_by_id
20    from .tools.coin_historical_chart_range_by_id import get_coin_historical_chart_range_by_id
21    from .tools.market_discovery import (
22        get_trending,
23        get_top_gainers_losers,
24        get_new_coins,
25    )
26    from .tools.global_data import (
27        get_global,
28        get_global_defi,
29    )
30    from .tools.derivatives import (
31        get_derivatives,
32        get_derivatives_exchanges,
33        get_categories,
34    )
35    # New imports for expanded API coverage
36    from .tools.coins import (
37        get_coins_list,
38        get_coins_markets,
39        get_coin_data,
40        get_coin_tickers,
41    )
42    from .tools.exchanges import (
43        get_exchanges,
44        get_exchange,
45        get_exchange_tickers,
46        get_exchange_volume_chart,
47    )
48    from .tools.nfts import (
49        get_nfts_list,
50        get_nft,
51        get_nft_by_contract,
52    )
53    from .tools.infrastructure import (
54        get_asset_platforms,
55        get_exchange_rates,
56        get_vs_currencies,
57        get_categories_list,
58    )
59    from .tools.search import search
60    from .tools.contracts import (
61        get_token_price,
62        get_coin_by_contract,
63    )
64    COINGECKO_AVAILABLE = True
65except ImportError as e:
66    logger.warning(f"CoinGecko tools not available: {e}")
67    COINGECKO_AVAILABLE = False
68 
69 
70class CoinPriceTool(BaseTool):
71    """
72    Get cryptocurrency prices at specific timestamps.
73 
74    Supports current price ("now") and historical prices.
75    Accepts coin IDs (bitcoin, ethereum) or symbols (BTC, ETH).
76    """
77 
78    @property
79    def name(self) -> str:
80        return "coin_price"
81 
82    @property
83    def description(self) -> str:
84        return """Get cryptocurrency prices. Supports current ("now") and historical prices.
85 
86If unsure about the coin ID, first use cg_search to find the correct ID.
87 
88Examples:
89- Get BTC current price: coin_price(coin_ids="bitcoin")
90- Get multiple coins: coin_price(coin_ids="BTC,ETH,SOL")
91- Get historical price: coin_price(coin_ids="bitcoin", timestamps=["2024-01-01"])"""
92 
93    @property
94    def parameters(self) -> dict:
95        return {
96            "type": "object",
97            "properties": {
98                "coin_ids": {
99                    "type": "string",
100                    "description": "Coin ID or symbol (bitcoin, BTC) or comma-separated list (BTC,ETH,SOL)"
101                },
102                "timestamps": {
103                    "type": "array",
104                    "items": {"type": "string"},
105                    "description": "List of timestamps. Use 'now' for current price, or date strings like '2024-01-01'",
106                    "default": ["now"]
107                },
108                "vs_currency": {
109                    "type": "string",
110                    "description": "Target currency (usd, eur, btc)",
111                    "default": "usd"
112                }
113            },
114            "required": ["coin_ids"]
115        }
116 
117    async def execute(
118        self,
119        ctx: ToolContext,
120        coin_ids: str,
121        timestamps: Optional[List[str]] = None,
122        vs_currency: str = "usd"
123    ) -> ToolResult:
124        if not COINGECKO_AVAILABLE:
125            return ToolResult(
126                success=False,
127                output=None,
128                error="CoinGecko tools not available. Check if /tools/coingecko exists."
129            )
130 
131        try:
132            result = await asyncio.to_thread(
133                get_coin_prices_at_timestamps,
134                coin_ids=coin_ids,
135                timestamps=timestamps or ["now"],
136                vs_currency=vs_currency
137            )
138            return ToolResult(success=True, output=result)
139        except Exception as e:
140            return ToolResult(success=False, output=None, error=str(e))
141 
142 
143class CoinOHLCTool(BaseTool):
144    """
145    Get OHLC (candlestick) data for a cryptocurrency.
146    """
147 
148    @property
149    def name(self) -> str:
150        return "coin_ohlc"
151 
152    @property
153    def description(self) -> str:
154        return """Get OHLC candlestick data for technical analysis.
155 
156Examples:
157- Get BTC daily OHLC for last 30 days: coin_ohlc(coin_id="bitcoin", days=30)
158- Get ETH 4h candles: coin_ohlc(coin_id="ethereum", days=7)"""
159 
160    @property
161    def parameters(self) -> dict:
162        return {
163            "type": "object",
164            "properties": {
165                "coin_id": {
166                    "type": "string",
167                    "description": "CoinGecko coin ID (bitcoin, ethereum, solana)"
168                },
169                "days": {
170                    "type": "integer",
171                    "description": "Number of days (1, 7, 14, 30, 90, 180, 365)",
172                    "default": 30
173                },
174                "vs_currency": {
175                    "type": "string",
176                    "description": "Target currency",
177                    "default": "usd"
178                }
179            },
180            "required": ["coin_id"]
181        }
182 
183    async def execute(
184        self,
185        ctx: ToolContext,
186        coin_id: str,
187        days: int = 30,
188        vs_currency: str = "usd"
189    ) -> ToolResult:
190        if not COINGECKO_AVAILABLE:
191            return ToolResult(
192                success=False,
193                output=None,
194                error="CoinGecko tools not available."
195            )
196 
197        try:
198            import time
199            to_timestamp = int(time.time())
200            from_timestamp = to_timestamp - (days * 24 * 60 * 60)
201 
202            result = await asyncio.to_thread(
203                get_coin_ohlc_range_by_id,
204                coin_id=coin_id,
205                from_timestamp=from_timestamp,
206                to_timestamp=to_timestamp
207            )
208            return ToolResult(success=True, output=result)
209        except Exception as e:
210            return ToolResult(success=False, output=None, error=str(e))
211 
212 
213class CoinChartTool(BaseTool):
214    """
215    Get historical price chart data for a cryptocurrency.
216    """
217 
218    @property
219    def name(self) -> str:
220        return "coin_chart"
221 
222    @property
223    def description(self) -> str:
224        return """Get historical price chart data (prices, market caps, volumes).
225 
226Examples:
227- Get BTC 30-day chart: coin_chart(coin_id="bitcoin", days=30)
228- Get ETH 7-day chart: coin_chart(coin_id="ethereum", days=7)"""
229 
230    @property
231    def parameters(self) -> dict:
232        return {
233            "type": "object",
234            "properties": {
235                "coin_id": {
236                    "type": "string",
237                    "description": "CoinGecko coin ID"
238                },
239                "days": {
240                    "type": "integer",
241                    "description": "Number of days of data",
242                    "default": 30
243                },
244                "vs_currency": {
245                    "type": "string",
246                    "default": "usd"
247                }
248            },
249            "required": ["coin_id"]
250        }
251 
252    async def execute(
253        self,
254        ctx: ToolContext,
255        coin_id: str,
256        days: int = 30,
257        vs_currency: str = "usd"
258    ) -> ToolResult:
259        if not COINGECKO_AVAILABLE:
260            return ToolResult(
261                success=False,
262                output=None,
263                error="CoinGecko tools not available."
264            )
265 
266        try:
267            import time
268            to_timestamp = int(time.time())
269            from_timestamp = to_timestamp - (days * 24 * 60 * 60)
270 
271            result = await asyncio.to_thread(
272                get_coin_historical_chart_range_by_id,
273                coin_id=coin_id,
274                vs_currency=vs_currency,
275                from_timestamp=from_timestamp,
276                to_timestamp=to_timestamp
277            )
278            return ToolResult(success=True, output=result)
279        except Exception as e:
280            return ToolResult(success=False, output=None, error=str(e))
281 
282 
283# ==================== Market Discovery Tools ====================
284 
285class CoinGeckoTrendingTool(BaseTool):
286    """
287    Get trending coins based on user search data.
288    """
289 
290    @property
291    def name(self) -> str:
292        return "cg_trending"
293 
294    @property
295    def description(self) -> str:
296        return """Get trending coins in the last 24 hours based on user search data.
297 
298Also returns trending NFTs and categories.
299 
300Examples:
301- Get trending: cg_trending()"""
302 
303    @property
304    def parameters(self) -> dict:
305        return {
306            "type": "object",
307            "properties": {}
308        }
309 
310    async def execute(self, ctx: ToolContext) -> ToolResult:
311        if not COINGECKO_AVAILABLE:
312            return ToolResult(
313                success=False,
314                output=None,
315                error="CoinGecko tools not available."
316            )
317 
318        try:
319            result = await asyncio.to_thread(get_trending)
320            return ToolResult(success=True, output=result)
321        except Exception as e:
322            return ToolResult(success=False, output=None, error=str(e))
323 
324 
325class CoinGeckoTopGainersLosersTool(BaseTool):
326    """
327    Get top gainers and losers by price change.
328    """
329 
330    @property
331    def name(self) -> str:
332        return "cg_top_gainers_losers"
333 
334    @property
335    def description(self) -> str:
336        return """Get top 30 gainers and losers by price change percentage.
337 
338Examples:
339- Get 24h movers: cg_top_gainers_losers()
340- Get 7d movers: cg_top_gainers_losers(duration="7d")"""
341 
342    @property
343    def parameters(self) -> dict:
344        return {
345            "type": "object",
346            "properties": {
347                "vs_currency": {
348                    "type": "string",
349                    "description": "Target currency",
350                    "default": "usd"
351                },
352                "duration": {
353                    "type": "string",
354                    "description": "Time duration: 1h, 24h, 7d, 14d, 30d, 60d, 1y",
355                    "default": "24h"
356                }
357            }
358        }
359 
360    async def execute(
361        self,
362        ctx: ToolContext,
363        vs_currency: str = "usd",
364        duration: str = "24h"
365    ) -> ToolResult:
366        if not COINGECKO_AVAILABLE:
367            return ToolResult(
368                success=False,
369                output=None,
370                error="CoinGecko tools not available."
371            )
372 
373        try:
374            result = await asyncio.to_thread(get_top_gainers_losers, vs_currency, duration)
375            return ToolResult(success=True, output=result)
376        except Exception as e:
377            return ToolResult(success=False, output=None, error=str(e))
378 
379 
380class CoinGeckoNewCoinsTool(BaseTool):
381    """
382    Get recently added coins.
383    """
384 
385    @property
386    def name(self) -> str:
387        return "cg_new_coins"
388 
389    @property
390    def description(self) -> str:
391        return """Get recently added coins to CoinGecko.
392 
393Examples:
394- Get new coins: cg_new_coins()"""
395 
396    @property
397    def parameters(self) -> dict:
398        return {
399            "type": "object",
400            "properties": {}
401        }
402 
403    async def execute(self, ctx: ToolContext) -> ToolResult:
404        if not COINGECKO_AVAILABLE:
405            return ToolResult(
406                success=False,
407                output=None,
408                error="CoinGecko tools not available."
409            )
410 
411        try:
412            result = await asyncio.to_thread(get_new_coins)
413            return ToolResult(success=True, output=result)
414        except Exception as e:
415            return ToolResult(success=False, output=None, error=str(e))
416 
417 
418# ==================== Global Data Tools ====================
419 
420class CoinGeckoGlobalTool(BaseTool):
421    """
422    Get global cryptocurrency market statistics.
423    """
424 
425    @property
426    def name(self) -> str:
427        return "cg_global"
428 
429    @property
430    def description(self) -> str:
431        return """Get global cryptocurrency market statistics.
432 
433Returns total market cap, volume, BTC dominance, and more.
434 
435Examples:
436- Get global stats: cg_global()"""
437 
438    @property
439    def parameters(self) -> dict:
440        return {
441            "type": "object",
442            "properties": {}
443        }
444 
445    async def execute(self, ctx: ToolContext) -> ToolResult:
446        if not COINGECKO_AVAILABLE:
447            return ToolResult(
448                success=False,
449                output=None,
450                error="CoinGecko tools not available."
451            )
452 
453        try:
454            result = await asyncio.to_thread(get_global)
455            return ToolResult(success=True, output=result)
456        except Exception as e:
457            return ToolResult(success=False, output=None, error=str(e))
458 
459 
460class CoinGeckoGlobalDefiTool(BaseTool):
461    """
462    Get global DeFi market statistics.
463    """
464 
465    @property
466    def name(self) -> str:
467        return "cg_global_defi"
468 
469    @property
470    def description(self) -> str:
471        return """Get global DeFi market statistics.
472 
473Returns DeFi market cap, TVL, DeFi dominance.
474 
475Examples:
476- Get DeFi stats: cg_global_defi()"""
477 
478    @property
479    def parameters(self) -> dict:
480        return {
481            "type": "object",
482            "properties": {}
483        }
484 
485    async def execute(self, ctx: ToolContext) -> ToolResult:
486        if not COINGECKO_AVAILABLE:
487            return ToolResult(
488                success=False,
489                output=None,
490                error="CoinGecko tools not available."
491            )
492 
493        try:
494            result = await asyncio.to_thread(get_global_defi)
495            return ToolResult(success=True, output=result)
496        except Exception as e:
497            return ToolResult(success=False, output=None, error=str(e))
498 
499 
500# ==================== Derivatives Tools ====================
501 
502class CoinGeckoDerivativesTool(BaseTool):
503    """
504    Get all derivatives tickers.
505    """
506 
507    @property
508    def name(self) -> str:
509        return "cg_derivatives"
510 
511    @property
512    def description(self) -> str:
513        return """Get all derivatives tickers (perpetuals, futures).
514 
515Includes funding rates, open interest, spread, basis.
516 
517Examples:
518- Get all derivatives: cg_derivatives()
519- Get unexpired only: cg_derivatives(include_tickers="unexpired")"""
520 
521    @property
522    def parameters(self) -> dict:
523        return {
524            "type": "object",
525            "properties": {
526                "include_tickers": {
527                    "type": "string",
528                    "description": "Filter: all or unexpired",
529                    "default": "unexpired"
530                }
531            }
532        }
533 
534    async def execute(
535        self,
536        ctx: ToolContext,
537        include_tickers: str = "unexpired"
538    ) -> ToolResult:
539        if not COINGECKO_AVAILABLE:
540            return ToolResult(
541                success=False,
542                output=None,
543                error="CoinGecko tools not available."
544            )
545 
546        try:
547            result = await asyncio.to_thread(get_derivatives, include_tickers)
548            return ToolResult(success=True, output=result)
549        except Exception as e:
550            return ToolResult(success=False, output=None, error=str(e))
551 
552 
553class CoinGeckoDerivativesExchangesTool(BaseTool):
554    """
555    Get derivatives exchanges with rankings.
556    """
557 
558    @property
559    def name(self) -> str:
560        return "cg_derivatives_exchanges"
561 
562    @property
563    def description(self) -> str:
564        return """Get list of derivatives exchanges with ranking.
565 
566Sorted by open interest or volume.
567 
568Examples:
569- Get exchanges by OI: cg_derivatives_exchanges()
570- Get exchanges by volume: cg_derivatives_exchanges(order="trade_volume_24h_btc_desc")"""
571 
572    @property
573    def parameters(self) -> dict:
574        return {
575            "type": "object",
576            "properties": {
577                "order": {
578                    "type": "string",
579                    "description": "Sort order",
580                    "default": "open_interest_btc_desc"
581                },
582                "per_page": {
583                    "type": "integer",
584                    "description": "Results per page (max 100)",
585                    "default": 50
586                }
587            }
588        }
589 
590    async def execute(
591        self,
592        ctx: ToolContext,
593        order: str = "open_interest_btc_desc",
594        per_page: int = 50
595    ) -> ToolResult:
596        if not COINGECKO_AVAILABLE:
597            return ToolResult(
598                success=False,
599                output=None,
600                error="CoinGecko tools not available."
601            )
602 
603        try:
604            result = await asyncio.to_thread(get_derivatives_exchanges, order, per_page)
605            return ToolResult(success=True, output=result)
606        except Exception as e:
607            return ToolResult(success=False, output=None, error=str(e))
608 
609 
610class CoinGeckoCategoriesjTool(BaseTool):
611    """
612    Get coin categories with market data.
613    """
614 
615    @property
616    def name(self) -> str:
617        return "cg_categories"
618 
619    @property
620    def description(self) -> str:
621        return """Get coin categories with market data (DeFi, L1, L2, Memes, etc.).
622 
623See sector performance and top coins in each category.
624 
625Examples:
626- Get categories by market cap: cg_categories()
627- Get categories by 24h change: cg_categories(order="market_cap_change_24h_desc")"""
628 
629    @property
630    def parameters(self) -> dict:
631        return {
632            "type": "object",
633            "properties": {
634                "order": {
635                    "type": "string",
636                    "description": "Sort order: market_cap_desc, market_cap_change_24h_desc, etc.",
637                    "default": "market_cap_desc"
638                }
639            }
640        }
641 
642    async def execute(
643        self,
644        ctx: ToolContext,
645        order: str = "market_cap_desc"
646    ) -> ToolResult:
647        if not COINGECKO_AVAILABLE:
648            return ToolResult(
649                success=False,
650                output=None,
651                error="CoinGecko tools not available."
652            )
653 
654        try:
655            result = await asyncio.to_thread(get_categories, order)
656            return ToolResult(success=True, output=result)
657        except Exception as e:
658            return ToolResult(success=False, output=None, error=str(e))
659 
660 
661# ==================== Coin Data Tools ====================
662 
663class CoinGeckoCoinsListTool(BaseTool):
664    """
665    Get all supported coins with IDs, names, and symbols.
666    """
667 
668    @property
669    def name(self) -> str:
670        return "cg_coins_list"
671 
672    @property
673    def description(self) -> str:
674        return """Get all supported coins with id, symbol, and name.
675 
676Useful for coin discovery and ID lookup.
677 
678Examples:
679- Get all coins: cg_coins_list()
680- Get coins with platform addresses: cg_coins_list(include_platform=True)"""
681 
682    @property
683    def parameters(self) -> dict:
684        return {
685            "type": "object",
686            "properties": {
687                "include_platform": {
688                    "type": "boolean",
689                    "description": "Include platform contract addresses",
690                    "default": False
691                }
692            }
693        }
694 
695    async def execute(
696        self,
697        ctx: ToolContext,
698        include_platform: bool = False
699    ) -> ToolResult:
700        if not COINGECKO_AVAILABLE:
701            return ToolResult(
702                success=False,
703                output=None,
704                error="CoinGecko tools not available."
705            )
706 
707        try:
708            result = await asyncio.to_thread(get_coins_list, include_platform)
709            return ToolResult(success=True, output=result)
710        except Exception as e:
711            return ToolResult(success=False, output=None, error=str(e))
712 
713 
714class CoinGeckoCoinsMarketsTool(BaseTool):
715    """
716    Get bulk market data for coins with sorting and filtering.
717    """
718 
719    @property
720    def name(self) -> str:
721        return "cg_coins_markets"
722 
723    @property
724    def description(self) -> str:
725        return """Get market data for coins with sorting, filtering, and pagination.
726 
727Screen coins by market cap, volume, price change, or category.
728 
729Examples:
730- Get top 100 by market cap: cg_coins_markets()
731- Get top by volume: cg_coins_markets(order="volume_desc")
732- Get DeFi coins: cg_coins_markets(category="decentralized-finance-defi")
733- Get specific coins: cg_coins_markets(ids="bitcoin,ethereum,solana")"""
734 
735    @property
736    def parameters(self) -> dict:
737        return {
738            "type": "object",
739            "properties": {
740                "vs_currency": {
741                    "type": "string",
742                    "description": "Target currency (usd, eur, btc)",
743                    "default": "usd"
744                },
745                "order": {
746                    "type": "string",
747                    "description": "Sort order: market_cap_desc, volume_desc, price_change_24h_desc",
748                    "default": "market_cap_desc"
749                },
750                "per_page": {
751                    "type": "integer",
752                    "description": "Results per page (max 250)",
753                    "default": 100
754                },
755                "page": {
756                    "type": "integer",
757                    "description": "Page number",
758                    "default": 1
759                },
760                "sparkline": {
761                    "type": "boolean",
762                    "description": "Include 7-day sparkline data",
763                    "default": False
764                },
765                "price_change_percentage": {
766                    "type": "string",
767                    "description": "Price change periods (comma-separated): 1h, 24h, 7d, 14d, 30d, 200d, 1y",
768                    "default": "24h"
769                },
770                "category": {
771                    "type": "string",
772                    "description": "Filter by category id"
773                },
774                "ids": {
775                    "type": "string",
776                    "description": "Comma-separated coin ids to filter"
777                }
778            }
779        }
780 
781    async def execute(
782        self,
783        ctx: ToolContext,
784        vs_currency: str = "usd",
785        order: str = "market_cap_desc",
786        per_page: int = 100,
787        page: int = 1,
788        sparkline: bool = False,
789        price_change_percentage: str = "24h",
790        category: Optional[str] = None,
791        ids: Optional[str] = None
792    ) -> ToolResult:
793        if not COINGECKO_AVAILABLE:
794            return ToolResult(
795                success=False,
796                output=None,
797                error="CoinGecko tools not available."
798            )
799 
800        try:
801            result = await asyncio.to_thread(
802                get_coins_markets,
803                vs_currency=vs_currency,
804                order=order,
805                per_page=per_page,
806                page=page,
807                sparkline=sparkline,
808                price_change_percentage=price_change_percentage,
809                category=category,
810                ids=ids
811            )
812            return ToolResult(success=True, output=result)
813        except Exception as e:
814            return ToolResult(success=False, output=None, error=str(e))
815 
816 
817class CoinGeckoCoinDataTool(BaseTool):
818    """
819    Get full coin metadata including description, links, ATH, ATL.
820    """
821 
822    @property
823    def name(self) -> str:
824        return "cg_coin_data"
825 
826    @property
827    def description(self) -> str:
828        return """Get comprehensive coin data including description, links, ATH, ATL, market data.
829 
830Deep research on specific coin.
831 
832Examples:
833- Get Bitcoin data: cg_coin_data(coin_id="bitcoin")
834- Include tickers: cg_coin_data(coin_id="ethereum", tickers=True)
835- Full data: cg_coin_data(coin_id="solana", community_data=True, developer_data=True)"""
836 
837    @property
838    def parameters(self) -> dict:
839        return {
840            "type": "object",
841            "properties": {
842                "coin_id": {
843                    "type": "string",
844                    "description": "CoinGecko coin ID (bitcoin, ethereum, solana)"
845                },
846                "localization": {
847                    "type": "boolean",
848                    "description": "Include localized languages",
849                    "default": False
850                },
851                "tickers": {
852                    "type": "boolean",
853                    "description": "Include tickers data",
854                    "default": False
855                },
856                "market_data": {
857                    "type": "boolean",
858                    "description": "Include market data",
859                    "default": True
860                },
861                "community_data": {
862                    "type": "boolean",
863                    "description": "Include community data",
864                    "default": False
865                },
866                "developer_data": {
867                    "type": "boolean",
868                    "description": "Include developer data",
869                    "default": False
870                },
871                "sparkline": {
872                    "type": "boolean",
873                    "description": "Include sparkline 7 days data",
874                    "default": False
875                }
876            },
877            "required": ["coin_id"]
878        }
879 
880    async def execute(
881        self,
882        ctx: ToolContext,
883        coin_id: str,
884        localization: bool = False,
885        tickers: bool = False,
886        market_data: bool = True,
887        community_data: bool = False,
888        developer_data: bool = False,
889        sparkline: bool = False
890    ) -> ToolResult:
891        if not COINGECKO_AVAILABLE:
892            return ToolResult(
893                success=False,
894                output=None,
895                error="CoinGecko tools not available."
896            )
897 
898        try:
899            result = await asyncio.to_thread(
900                get_coin_data,
901                coin_id=coin_id,
902                localization=localization,
903                tickers=tickers,
904                market_data=market_data,
905                community_data=community_data,
906                developer_data=developer_data,
907                sparkline=sparkline
908            )
909            return ToolResult(success=True, output=result)
910        except Exception as e:
911            return ToolResult(success=False, output=None, error=str(e))
912 
913 
914class CoinGeckoCoinTickersTool(BaseTool):
915    """
916    Get all trading pairs/tickers for a coin across exchanges.
917    """
918 
919    @property
920    def name(self) -> str:
921        return "cg_coin_tickers"
922 
923    @property
924    def description(self) -> str:
925        return """Get all trading pairs/tickers for a coin across exchanges.
926 
927Find liquidity and arbitrage opportunities.
928 
929Examples:
930- Get BTC tickers: cg_coin_tickers(coin_id="bitcoin")
931- Filter by exchange: cg_coin_tickers(coin_id="ethereum", exchange_ids="binance")
932- With depth: cg_coin_tickers(coin_id="solana", depth=True)"""
933 
934    @property
935    def parameters(self) -> dict:
936        return {
937            "type": "object",
938            "properties": {
939                "coin_id": {
940                    "type": "string",
941                    "description": "CoinGecko coin ID"
942                },
943                "exchange_ids": {
944                    "type": "string",
945                    "description": "Comma-separated exchange ids to filter"
946                },
947                "include_exchange_logo": {
948                    "type": "boolean",
949                    "description": "Include exchange logo",
950                    "default": False
951                },
952                "page": {
953                    "type": "integer",
954                    "description": "Page number",
955                    "default": 1
956                },
957                "order": {
958                    "type": "string",
959                    "description": "Sort order: trust_score_desc, volume_desc",
960                    "default": "volume_desc"
961                },
962                "depth": {
963                    "type": "boolean",
964                    "description": "Include order book depth",
965                    "default": False
966                }
967            },
968            "required": ["coin_id"]
969        }
970 
971    async def execute(
972        self,
973        ctx: ToolContext,
974        coin_id: str,
975        exchange_ids: Optional[str] = None,
976        include_exchange_logo: bool = False,
977        page: int = 1,
978        order: str = "volume_desc",
979        depth: bool = False
980    ) -> ToolResult:
981        if not COINGECKO_AVAILABLE:
982            return ToolResult(
983                success=False,
984                output=None,
985                error="CoinGecko tools not available."
986            )
987 
988        try:
989            result = await asyncio.to_thread(
990                get_coin_tickers,
991                coin_id=coin_id,
992                exchange_ids=exchange_ids,
993                include_exchange_logo=include_exchange_logo,
994                page=page,
995                order=order,
996                depth=depth
997            )
998            return ToolResult(success=True, output=result)
999        except Exception as e:
1000            return ToolResult(success=False, output=None, error=str(e))
1001 
1002 
1003# ==================== Exchange Tools ====================
1004 
1005class CoinGeckoExchangesTool(BaseTool):
1006    """
1007    Get all spot exchanges with volumes and trust scores.
1008    """
1009 
1010    @property
1011    def name(self) -> str:
1012        return "cg_exchanges"
1013 
1014    @property
1015    def description(self) -> str:
1016        return """Get all spot exchanges with volumes and trust scores.
1017 
1018Compare exchanges by volume and trust.
1019 
1020Examples:
1021- Get top 100 exchanges: cg_exchanges()
1022- Paginate: cg_exchanges(per_page=50, page=2)"""
1023 
1024    @property
1025    def parameters(self) -> dict:
1026        return {
1027            "type": "object",
1028            "properties": {
1029                "per_page": {
1030                    "type": "integer",
1031                    "description": "Results per page (max 250)",
1032                    "default": 100
1033                },
1034                "page": {
1035                    "type": "integer",
1036                    "description": "Page number",
1037                    "default": 1
1038                }
1039            }
1040        }
1041 
1042    async def execute(
1043        self,
1044        ctx: ToolContext,
1045        per_page: int = 100,
1046        page: int = 1
1047    ) -> ToolResult:
1048        if not COINGECKO_AVAILABLE:
1049            return ToolResult(
1050                success=False,
1051                output=None,
1052                error="CoinGecko tools not available."
1053            )
1054 
1055        try:
1056            result = await asyncio.to_thread(get_exchanges, per_page, page)
1057            return ToolResult(success=True, output=result)
1058        except Exception as e:
1059            return ToolResult(success=False, output=None, error=str(e))
1060 
1061 
1062class CoinGeckoExchangeTool(BaseTool):
1063    """
1064    Get detailed exchange data.
1065    """
1066 
1067    @property
1068    def name(self) -> str:
1069        return "cg_exchange"
1070 
1071    @property
1072    def description(self) -> str:
1073        return """Get detailed exchange data including tickers and BTC volume.
1074 
1075Research specific exchange.
1076 
1077Examples:
1078- Get Binance data: cg_exchange(exchange_id="binance")
1079- Get Coinbase data: cg_exchange(exchange_id="coinbase-exchange")"""
1080 
1081    @property
1082    def parameters(self) -> dict:
1083        return {
1084            "type": "object",
1085            "properties": {
1086                "exchange_id": {
1087                    "type": "string",
1088                    "description": "CoinGecko exchange ID (binance, coinbase-exchange)"
1089                }
1090            },
1091            "required": ["exchange_id"]
1092        }
1093 
1094    async def execute(
1095        self,
1096        ctx: ToolContext,
1097        exchange_id: str
1098    ) -> ToolResult:
1099        if not COINGECKO_AVAILABLE:
1100            return ToolResult(
1101                success=False,
1102                output=None,
1103                error="CoinGecko tools not available."
1104            )
1105 
1106        try:
1107            result = await asyncio.to_thread(get_exchange, exchange_id)
1108            return ToolResult(success=True, output=result)
1109        except Exception as e:
1110            return ToolResult(success=False, output=None, error=str(e))
1111 
1112 
1113class CoinGeckoExchangeTickersTool(BaseTool):
1114    """
1115    Get all trading pairs on an exchange.
1116    """
1117 
1118    @property
1119    def name(self) -> str:
1120        return "cg_exchange_tickers"
1121 
1122    @property
1123    def description(self) -> str:
1124        return """Get all trading pairs on an exchange.
1125 
1126Find trading opportunities on specific exchange.
1127 
1128Examples:
1129- Get Binance pairs: cg_exchange_tickers(exchange_id="binance")
1130- Filter by coin: cg_exchange_tickers(exchange_id="coinbase-exchange", coin_ids="bitcoin")"""
1131 
1132    @property
1133    def parameters(self) -> dict:
1134        return {
1135            "type": "object",
1136            "properties": {
1137                "exchange_id": {
1138                    "type": "string",
1139                    "description": "CoinGecko exchange ID"
1140                },
1141                "coin_ids": {
1142                    "type": "string",
1143                    "description": "Comma-separated coin ids to filter"
1144                },
1145                "include_exchange_logo": {
1146                    "type": "boolean",
1147                    "description": "Include exchange logo",
1148                    "default": False
1149                },
1150                "page": {
1151                    "type": "integer",
1152                    "description": "Page number",
1153                    "default": 1
1154                },
1155                "order": {
1156                    "type": "string",
1157                    "description": "Sort order: trust_score_desc, volume_desc",
1158                    "default": "volume_desc"
1159                },
1160                "depth": {
1161                    "type": "boolean",
1162                    "description": "Include order book depth",
1163                    "default": False
1164                }
1165            },
1166            "required": ["exchange_id"]
1167        }
1168 
1169    async def execute(
1170        self,
1171        ctx: ToolContext,
1172        exchange_id: str,
1173        coin_ids: Optional[str] = None,
1174        include_exchange_logo: bool = False,
1175        page: int = 1,
1176        order: str = "volume_desc",
1177        depth: bool = False
1178    ) -> ToolResult:
1179        if not COINGECKO_AVAILABLE:
1180            return ToolResult(
1181                success=False,
1182                output=None,
1183                error="CoinGecko tools not available."
1184            )
1185 
1186        try:
1187            result = await asyncio.to_thread(
1188                get_exchange_tickers,
1189                exchange_id=exchange_id,
1190                coin_ids=coin_ids,
1191                include_exchange_logo=include_exchange_logo,
1192                page=page,
1193                order=order,
1194                depth=depth
1195            )
1196            return ToolResult(success=True, output=result)
1197        except Exception as e:
1198            return ToolResult(success=False, output=None, error=str(e))
1199 
1200 
1201class CoinGeckoExchangeVolumeChartTool(BaseTool):
1202    """
1203    Get historical volume chart for an exchange.
1204    """
1205 
1206    @property
1207    def name(self) -> str:
1208        return "cg_exchange_volume_chart"
1209 
1210    @property
1211    def description(self) -> str:
1212        return """Get historical volume chart for an exchange.
1213 
1214Track exchange growth over time.
1215 
1216Examples:
1217- Get Binance 30-day volume: cg_exchange_volume_chart(exchange_id="binance")
1218- Get 90-day history: cg_exchange_volume_chart(exchange_id="coinbase-exchange", days=90)"""
1219 
1220    @property
1221    def parameters(self) -> dict:
1222        return {
1223            "type": "object",
1224            "properties": {
1225                "exchange_id": {
1226                    "type": "string",
1227                    "description": "CoinGecko exchange ID"
1228                },
1229                "days": {
1230                    "type": "integer",
1231                    "description": "Number of days (1, 7, 14, 30, 90, 180, 365)",
1232                    "default": 30
1233                }
1234            },
1235            "required": ["exchange_id"]
1236        }
1237 
1238    async def execute(
1239        self,
1240        ctx: ToolContext,
1241        exchange_id: str,
1242        days: int = 30
1243    ) -> ToolResult:
1244        if not COINGECKO_AVAILABLE:
1245            return ToolResult(
1246                success=False,
1247                output=None,
1248                error="CoinGecko tools not available."
1249            )
1250 
1251        try:
1252            result = await asyncio.to_thread(get_exchange_volume_chart, exchange_id, days)
1253            return ToolResult(success=True, output=result)
1254        except Exception as e:
1255            return ToolResult(success=False, output=None, error=str(e))
1256 
1257 
1258# ==================== NFT Tools ====================
1259 
1260class CoinGeckoNFTsListTool(BaseTool):
1261    """
1262    Get all NFT collections.
1263    """
1264 
1265    @property
1266    def name(self) -> str:
1267        return "cg_nfts_list"
1268 
1269    @property
1270    def description(self) -> str:
1271        return """Get all NFT collections with IDs and contract addresses.
1272 
1273NFT discovery.
1274 
1275Examples:
1276- Get top NFTs by market cap: cg_nfts_list()
1277- Sort by volume: cg_nfts_list(order="h24_volume_usd_desc")"""
1278 
1279    @property
1280    def parameters(self) -> dict:
1281        return {
1282            "type": "object",
1283            "properties": {
1284                "order": {
1285                    "type": "string",
1286                    "description": "Sort order: market_cap_usd_desc, h24_volume_usd_desc",
1287                    "default": "market_cap_usd_desc"
1288                },
1289                "per_page": {
1290                    "type": "integer",
1291                    "description": "Results per page (max 250)",
1292                    "default": 100
1293                },
1294                "page": {
1295                    "type": "integer",
1296                    "description": "Page number",
1297                    "default": 1
1298                }
1299            }
1300        }
1301 
1302    async def execute(
1303        self,
1304        ctx: ToolContext,
1305        order: str = "market_cap_usd_desc",
1306        per_page: int = 100,
1307        page: int = 1
1308    ) -> ToolResult:
1309        if not COINGECKO_AVAILABLE:
1310            return ToolResult(
1311                success=False,
1312                output=None,
1313                error="CoinGecko tools not available."
1314            )
1315 
1316        try:
1317            result = await asyncio.to_thread(get_nfts_list, order, per_page, page)
1318            return ToolResult(success=True, output=result)
1319        except Exception as e:
1320            return ToolResult(success=False, output=None, error=str(e))
1321 
1322 
1323class CoinGeckoNFTTool(BaseTool):
1324    """
1325    Get NFT collection data.
1326    """
1327 
1328    @property
1329    def name(self) -> str:
1330        return "cg_nft"
1331 
1332    @property
1333    def description(self) -> str:
1334        return """Get NFT collection data including floor price, volume, market cap.
1335 
1336NFT research.
1337 
1338Examples:
1339- Get Bored Apes: cg_nft(nft_id="bored-ape-yacht-club")
1340- Get CryptoPunks: cg_nft(nft_id="cryptopunks")"""
1341 
1342    @property
1343    def parameters(self) -> dict:
1344        return {
1345            "type": "object",
1346            "properties": {
1347                "nft_id": {
1348                    "type": "string",
1349                    "description": "CoinGecko NFT collection ID"
1350                }
1351            },
1352            "required": ["nft_id"]
1353        }
1354 
1355    async def execute(
1356        self,
1357        ctx: ToolContext,
1358        nft_id: str
1359    ) -> ToolResult:
1360        if not COINGECKO_AVAILABLE:
1361            return ToolResult(
1362                success=False,
1363                output=None,
1364                error="CoinGecko tools not available."
1365            )
1366 
1367        try:
1368            result = await asyncio.to_thread(get_nft, nft_id)
1369            return ToolResult(success=True, output=result)
1370        except Exception as e:
1371            return ToolResult(success=False, output=None, error=str(e))
1372 
1373 
1374class CoinGeckoNFTByContractTool(BaseTool):
1375    """
1376    Get NFT collection by contract address.
1377    """
1378 
1379    @property
1380    def name(self) -> str:
1381        return "cg_nft_by_contract"
1382 
1383    @property
1384    def description(self) -> str:
1385        return """Get NFT collection by contract address.
1386 
1387On-chain NFT lookup.
1388 
1389Examples:
1390- Get BAYC by contract: cg_nft_by_contract(asset_platform="ethereum", contract_address="0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d")"""
1391 
1392    @property
1393    def parameters(self) -> dict:
1394        return {
1395            "type": "object",
1396            "properties": {
1397                "asset_platform": {
1398                    "type": "string",
1399                    "description": "Asset platform id (ethereum, solana)"
1400                },
1401                "contract_address": {
1402                    "type": "string",
1403                    "description": "NFT contract address"
1404                }
1405            },
1406            "required": ["asset_platform", "contract_address"]
1407        }
1408 
1409    async def execute(
1410        self,
1411        ctx: ToolContext,
1412        asset_platform: str,
1413        contract_address: str
1414    ) -> ToolResult:
1415        if not COINGECKO_AVAILABLE:
1416            return ToolResult(
1417                success=False,
1418                output=None,
1419                error="CoinGecko tools not available."
1420            )
1421 
1422        try:
1423            result = await asyncio.to_thread(get_nft_by_contract, asset_platform, contract_address)
1424            return ToolResult(success=True, output=result)
1425        except Exception as e:
1426            return ToolResult(success=False, output=None, error=str(e))
1427 
1428 
1429# ==================== Infrastructure Tools ====================
1430 
1431class CoinGeckoAssetPlatformsTool(BaseTool):
1432    """
1433    Get all blockchain networks/asset platforms.
1434    """
1435 
1436    @property
1437    def name(self) -> str:
1438        return "cg_asset_platforms"
1439 
1440    @property
1441    def description(self) -> str:
1442        return """Get all blockchain networks (Ethereum, Solana, etc.).
1443 
1444Filter by chain.
1445 
1446Examples:
1447- Get all platforms: cg_asset_platforms()
1448- Filter NFT platforms: cg_asset_platforms(filter="nft")"""
1449 
1450    @property
1451    def parameters(self) -> dict:
1452        return {
1453            "type": "object",
1454            "properties": {
1455                "filter": {
1456                    "type": "string",
1457                    "description": "Filter platforms (e.g., nft)"
1458                }
1459            }
1460        }
1461 
1462    async def execute(
1463        self,
1464        ctx: ToolContext,
1465        filter: Optional[str] = None
1466    ) -> ToolResult:
1467        if not COINGECKO_AVAILABLE:
1468            return ToolResult(
1469                success=False,
1470                output=None,
1471                error="CoinGecko tools not available."
1472            )
1473 
1474        try:
1475            result = await asyncio.to_thread(get_asset_platforms, filter)
1476            return ToolResult(success=True, output=result)
1477        except Exception as e:
1478            return ToolResult(success=False, output=None, error=str(e))
1479 
1480 
1481class CoinGeckoExchangeRatesTool(BaseTool):
1482    """
1483    Get BTC exchange rates to all fiat currencies.
1484    """
1485 
1486    @property
1487    def name(self) -> str:
1488        return "cg_exchange_rates"
1489 
1490    @property
1491    def description(self) -> str:
1492        return """Get BTC exchange rates to all fiat currencies.
1493 
1494Currency conversion.
1495 
1496Examples:
1497- Get exchange rates: cg_exchange_rates()"""
1498 
1499    @property
1500    def parameters(self) -> dict:
1501        return {
1502            "type": "object",
1503            "properties": {}
1504        }
1505 
1506    async def execute(self, ctx: ToolContext) -> ToolResult:
1507        if not COINGECKO_AVAILABLE:
1508            return ToolResult(
1509                success=False,
1510                output=None,
1511                error="CoinGecko tools not available."
1512            )
1513 
1514        try:
1515            result = await asyncio.to_thread(get_exchange_rates)
1516            return ToolResult(success=True, output=result)
1517        except Exception as e:
1518            return ToolResult(success=False, output=None, error=str(e))
1519 
1520 
1521class CoinGeckoVsCurrenciesTool(BaseTool):
1522    """
1523    Get list of supported quote currencies.
1524    """
1525 
1526    @property
1527    def name(self) -> str:
1528        return "cg_vs_currencies"
1529 
1530    @property
1531    def description(self) -> str:
1532        return """Get list of supported quote currencies (vs_currencies).
1533 
1534Reference data.
1535 
1536Examples:
1537- Get supported currencies: cg_vs_currencies()"""
1538 
1539    @property
1540    def parameters(self) -> dict:
1541        return {
1542            "type": "object",
1543            "properties": {}
1544        }
1545 
1546    async def execute(self, ctx: ToolContext) -> ToolResult:
1547        if not COINGECKO_AVAILABLE:
1548            return ToolResult(
1549                success=False,
1550                output=None,
1551                error="CoinGecko tools not available."
1552            )
1553 
1554        try:
1555            result = await asyncio.to_thread(get_vs_currencies)
1556            return ToolResult(success=True, output=result)
1557        except Exception as e:
1558            return ToolResult(success=False, output=None, error=str(e))
1559 
1560 
1561class CoinGeckoCategoriesListTool(BaseTool):
1562    """
1563    Get lightweight list of category names and IDs.
1564    """
1565 
1566    @property
1567    def name(self) -> str:
1568        return "cg_categories_list"
1569 
1570    @property
1571    def description(self) -> str:
1572        return """Get lightweight list of category names and IDs (no market data).
1573 
1574Quick lookup.
1575 
1576Examples:
1577- Get categories list: cg_categories_list()"""
1578 
1579    @property
1580    def parameters(self) -> dict:
1581        return {
1582            "type": "object",
1583            "properties": {}
1584        }
1585 
1586    async def execute(self, ctx: ToolContext) -> ToolResult:
1587        if not COINGECKO_AVAILABLE:
1588            return ToolResult(
1589                success=False,
1590                output=None,
1591                error="CoinGecko tools not available."
1592            )
1593 
1594        try:
1595            result = await asyncio.to_thread(get_categories_list)
1596            return ToolResult(success=True, output=result)
1597        except Exception as e:
1598            return ToolResult(success=False, output=None, error=str(e))
1599 
1600 
1601# ==================== Search Tool ====================
1602 
1603class CoinGeckoSearchTool(BaseTool):
1604    """
1605    Search for coins, exchanges, categories, and NFTs.
1606    """
1607 
1608    @property
1609    def name(self) -> str:
1610        return "cg_search"
1611 
1612    @property
1613    def description(self) -> str:
1614        return """Search for coins, exchanges, categories, and NFTs.
1615 
1616Discovery across all CoinGecko data.
1617 
1618Examples:
1619- Search for Solana: cg_search(query="solana")
1620- Search for DeFi: cg_search(query="defi")"""
1621 
1622    @property
1623    def parameters(self) -> dict:
1624        return {
1625            "type": "object",
1626            "properties": {
1627                "query": {
1628                    "type": "string",
1629                    "description": "Search query"
1630                }
1631            },
1632            "required": ["query"]
1633        }
1634 
1635    async def execute(
1636        self,
1637        ctx: ToolContext,
1638        query: str
1639    ) -> ToolResult:
1640        if not COINGECKO_AVAILABLE:
1641            return ToolResult(
1642                success=False,
1643                output=None,
1644                error="CoinGecko tools not available."
1645            )
1646 
1647        try:
1648            result = await asyncio.to_thread(search, query)
1649            return ToolResult(success=True, output=result)
1650        except Exception as e:
1651            return ToolResult(success=False, output=None, error=str(e))
1652 
1653 
1654# ==================== Contract Tools ====================
1655 
1656class CoinGeckoTokenPriceTool(BaseTool):
1657    """
1658    Get token prices by contract address.
1659    """
1660 
1661    @property
1662    def name(self) -> str:
1663        return "cg_token_price"
1664 
1665    @property
1666    def description(self) -> str:
1667        return """Get token prices by contract address.
1668 
1669On-chain pricing.
1670 
1671Examples:
1672- Get USDC price on Ethereum: cg_token_price(platform="ethereum", contract_addresses="0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")
1673- Multiple tokens: cg_token_price(platform="ethereum", contract_addresses="0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48,0xdac17f958d2ee523a2206206994597c13d831ec7")"""
1674 
1675    @property
1676    def parameters(self) -> dict:
1677        return {
1678            "type": "object",
1679            "properties": {
1680                "platform": {
1681                    "type": "string",
1682                    "description": "Asset platform id (ethereum, solana, polygon-pos)"
1683                },
1684                "contract_addresses": {
1685                    "type": "string",
1686                    "description": "Comma-separated contract addresses"
1687                },
1688                "vs_currencies": {
1689                    "type": "string",
1690                    "description": "Comma-separated target currencies (usd, eur, btc)",
1691                    "default": "usd"
1692                },
1693                "include_market_cap": {
1694                    "type": "boolean",
1695                    "description": "Include market cap",
1696                    "default": False
1697                },
1698                "include_24hr_vol": {
1699                    "type": "boolean",
1700                    "description": "Include 24h volume",
1701                    "default": False
1702                },
1703                "include_24hr_change": {
1704                    "type": "boolean",
1705                    "description": "Include 24h price change",
1706                    "default": False
1707                },
1708                "include_last_updated_at": {
1709                    "type": "boolean",
1710                    "description": "Include last updated timestamp",
1711                    "default": False
1712                }
1713            },
1714            "required": ["platform", "contract_addresses"]
1715        }
1716 
1717    async def execute(
1718        self,
1719        ctx: ToolContext,
1720        platform: str,
1721        contract_addresses: str,
1722        vs_currencies: str = "usd",
1723        include_market_cap: bool = False,
1724        include_24hr_vol: bool = False,
1725        include_24hr_change: bool = False,
1726        include_last_updated_at: bool = False
1727    ) -> ToolResult:
1728        if not COINGECKO_AVAILABLE:
1729            return ToolResult(
1730                success=False,
1731                output=None,
1732                error="CoinGecko tools not available."
1733            )
1734 
1735        try:
1736            result = await asyncio.to_thread(
1737                get_token_price,
1738                platform=platform,
1739                contract_addresses=contract_addresses,
1740                vs_currencies=vs_currencies,
1741                include_market_cap=include_market_cap,
1742                include_24hr_vol=include_24hr_vol,
1743                include_24hr_change=include_24hr_change,
1744                include_last_updated_at=include_last_updated_at
1745            )
1746            return ToolResult(success=True, output=result)
1747        except Exception as e:
1748            return ToolResult(success=False, output=None, error=str(e))
1749 
1750 
1751class CoinGeckoCoinByContractTool(BaseTool):
1752    """
1753    Get coin data by contract address.
1754    """
1755 
1756    @property
1757    def name(self) -> str:
1758        return "cg_coin_by_contract"
1759 
1760    @property
1761    def description(self) -> str:
1762        return """Get coin data by contract address.
1763 
1764On-chain lookup.
1765 
1766Examples:
1767- Get USDC on Ethereum: cg_coin_by_contract(platform="ethereum", contract_address="0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")"""
1768 
1769    @property
1770    def parameters(self) -> dict:
1771        return {
1772            "type": "object",
1773            "properties": {
1774                "platform": {
1775                    "type": "string",
1776                    "description": "Asset platform id (ethereum, solana, polygon-pos)"
1777                },
1778                "contract_address": {
1779                    "type": "string",
1780                    "description": "Token contract address"
1781                }
1782            },
1783            "required": ["platform", "contract_address"]
1784        }
1785 
1786    async def execute(
1787        self,
1788        ctx: ToolContext,
1789        platform: str,
1790        contract_address: str
1791    ) -> ToolResult:
1792        if not COINGECKO_AVAILABLE:
1793            return ToolResult(
1794                success=False,
1795                output=None,
1796                error="CoinGecko tools not available."
1797            )
1798 
1799        try:
1800            result = await asyncio.to_thread(get_coin_by_contract, platform, contract_address)
1801            return ToolResult(success=True, output=result)
1802        except Exception as e:
1803            return ToolResult(success=False, output=None, error=str(e))
1804