prediction-market-agent-tooling 0.55.0__py3-none-any.whl → 0.55.1__py3-none-any.whl

prediction_market_agent_tooling/config.py

@@ -1,10 +1,10 @@
 import typing as t
 
-from gnosis.eth import EthereumClient
-from gnosis.safe import Safe
 from pydantic.types import SecretStr
 from pydantic.v1.types import SecretStr as SecretStrV1
 from pydantic_settings import BaseSettings, SettingsConfigDict
+from safe_eth.eth import EthereumClient
+from safe_eth.safe.safe import SafeV141
 
 from prediction_market_agent_tooling.gtypes import (
     ChecksumAddress,
@@ -200,6 +200,6 @@ class APIKeys(BaseSettings):
         if not self.SAFE_ADDRESS:
             raise ValueError("Cannot check ownership if safe_address is not defined.")
 
-        s = Safe(self.SAFE_ADDRESS, ethereum_client)  # type: ignore[abstract]
+        s = SafeV141(self.SAFE_ADDRESS, ethereum_client)
         public_key_from_signer = private_key_to_public_key(self.bet_from_private_key)
         return s.retrieve_is_owner(public_key_from_signer)

prediction_market_agent_tooling/deploy/agent.py

@@ -30,6 +30,10 @@ from prediction_market_agent_tooling.deploy.gcp.utils import (
     gcp_function_is_active,
     gcp_resolve_api_keys_secrets,
 )
+from prediction_market_agent_tooling.deploy.trade_interval import (
+    FixedInterval,
+    TradeInterval,
+)
 from prediction_market_agent_tooling.gtypes import xDai, xdai_type
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import (
@@ -279,9 +283,10 @@ def {entrypoint_function_name}(request) -> str:
 
 class DeployablePredictionAgent(DeployableAgent):
     bet_on_n_markets_per_run: int = 1
+    n_markets_to_fetch: int = MAX_AVAILABLE_MARKETS
     min_balance_to_keep_in_native_currency: xDai | None = xdai_type(0.1)
     allow_invalid_questions: bool = False
-    same_market_bet_interval: timedelta = timedelta(hours=24)
+    same_market_trade_interval: TradeInterval = FixedInterval(timedelta(hours=24))
     # Only Metaculus allows to post predictions without trading (buying/selling of outcome tokens).
     supported_markets: t.Sequence[MarketType] = [MarketType.METACULUS]
 
@@ -345,7 +350,9 @@ class DeployablePredictionAgent(DeployableAgent):
         Subclasses can implement their own logic instead of this one, or on top of this one.
         By default, it allows only markets where user didn't bet recently and it's a reasonable question.
         """
-        if self.have_bet_on_market_since(market, since=self.same_market_bet_interval):
+        if self.have_bet_on_market_since(
+            market, since=self.same_market_trade_interval.get(market=market)
+        ):
             return False
 
         # Manifold allows to bet only on markets with probability between 1 and 99.
@@ -370,14 +377,13 @@ class DeployablePredictionAgent(DeployableAgent):
     def get_markets(
         self,
         market_type: MarketType,
-        limit: int = MAX_AVAILABLE_MARKETS,
         sort_by: SortBy = SortBy.CLOSING_SOONEST,
         filter_by: FilterBy = FilterBy.OPEN,
     ) -> t.Sequence[AgentMarket]:
         cls = market_type.market_class
         # Fetch the soonest closing markets to choose from
         available_markets = cls.get_binary_markets(
-            limit=limit, sort_by=sort_by, filter_by=filter_by
+            limit=self.n_markets_to_fetch, sort_by=sort_by, filter_by=filter_by
         )
         return available_markets
 

prediction_market_agent_tooling/deploy/trade_interval.py

@@ -0,0 +1,46 @@
+from abc import ABC, abstractmethod
+from datetime import timedelta
+
+from prediction_market_agent_tooling.markets.agent_market import AgentMarket
+from prediction_market_agent_tooling.tools.utils import check_not_none
+
+
+class TradeInterval(ABC):
+    @abstractmethod
+    def get(
+        self,
+        market: AgentMarket,
+    ) -> timedelta:
+        raise NotImplementedError("Subclass should implement this.")
+
+
+class FixedInterval(TradeInterval):
+    """
+    For trades at a fixed interval.
+    """
+
+    def __init__(self, interval: timedelta):
+        self.interval = interval
+
+    def get(
+        self,
+        market: AgentMarket,
+    ) -> timedelta:
+        return self.interval
+
+
+class MarketLifetimeProportionalInterval(TradeInterval):
+    """
+    For uniformly distributed trades over the market's lifetime.
+    """
+
+    def __init__(self, max_trades: int):
+        self.max_trades = max_trades
+
+    def get(
+        self,
+        market: AgentMarket,
+    ) -> timedelta:
+        created_time = check_not_none(market.created_time)
+        close_time = check_not_none(market.close_time)
+        return (close_time - created_time) / self.max_trades

prediction_market_agent_tooling/tools/relevant_news_analysis/data_models.py

@@ -0,0 +1,44 @@
+from pydantic import BaseModel, Field
+
+from prediction_market_agent_tooling.tools.tavily.tavily_models import TavilyResult
+
+
+class RelevantNewsAnalysis(BaseModel):
+    reasoning: str = Field(
+        ...,
+        description="The reason why the news contains information relevant to the given question. Or if no news is relevant, why not.",
+    )
+    contains_relevant_news: bool = Field(
+        ...,
+        description="A boolean flag for whether the news contains information relevant to the given question.",
+    )
+
+
+class RelevantNews(BaseModel):
+    question: str
+    url: str
+    summary: str
+    relevance_reasoning: str
+    days_ago: int
+
+    @staticmethod
+    def from_tavily_result_and_analysis(
+        question: str,
+        days_ago: int,
+        tavily_result: TavilyResult,
+        relevant_news_analysis: RelevantNewsAnalysis,
+    ) -> "RelevantNews":
+        return RelevantNews(
+            question=question,
+            url=tavily_result.url,
+            summary=tavily_result.content,
+            relevance_reasoning=relevant_news_analysis.reasoning,
+            days_ago=days_ago,
+        )
+
+
+class NoRelevantNews(BaseModel):
+    """
+    A placeholder model for when no relevant news is found. Enables ability to
+    distinguish between 'a cache hit with no news' and 'a cache miss'.
+    """

prediction_market_agent_tooling/tools/relevant_news_analysis/relevant_news_analysis.py

@@ -0,0 +1,162 @@
+from datetime import datetime, timedelta
+
+from langchain_core.output_parsers import PydanticOutputParser
+from langchain_core.prompts import PromptTemplate
+from langchain_openai import ChatOpenAI
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.tools.langfuse_ import (
+    get_langfuse_langchain_config,
+    observe,
+)
+from prediction_market_agent_tooling.tools.relevant_news_analysis.data_models import (
+    NoRelevantNews,
+    RelevantNews,
+    RelevantNewsAnalysis,
+)
+from prediction_market_agent_tooling.tools.relevant_news_analysis.relevant_news_cache import (
+    RelevantNewsResponseCache,
+)
+from prediction_market_agent_tooling.tools.tavily.tavily_search import (
+    get_relevant_news_since,
+)
+from prediction_market_agent_tooling.tools.tavily.tavily_storage import TavilyStorage
+from prediction_market_agent_tooling.tools.utils import check_not_none, utcnow
+
+SUMMARISE_RELEVANT_NEWS_PROMPT_TEMPLATE = """
+You are an expert news analyst, tracking stories that may affect your prediction to the outcome of a particular QUESTION.
+
+Your role is to identify only the relevant information from a scraped news site (RAW_CONTENT), analyse it, and determine whether it contains developments or announcements occurring **after** the DATE_OF_INTEREST that could affect the outcome of the QUESTION.
+
+Note that the news article may be published after the DATE_OF_INTEREST, but reference information that is older than the DATE_OF_INTEREST.
+
+[QUESTION]
+{question}
+
+[DATE_OF_INTEREST]
+{date_of_interest}
+
+[RAW_CONTENT]
+{raw_content}
+
+For your analysis, you should:
+- Discard the 'noise' from the raw content (e.g. ads, irrelevant content)
+- Consider ONLY information that would have a notable impact on the outcome of the question.
+- Consider ONLY information relating to an announcement or development that occurred **after** the DATE_OF_INTEREST.
+- Present this information concisely in your reasoning.
+- In your reasoning, do not use the term 'DATE_OF_INTEREST' directly. Use the actual date you are referring to instead.
+- In your reasoning, do not use the term 'RAW_CONTENT' directly. Refer to it as 'the article', or quote the content you are referring to.
+
+{format_instructions}
+"""
+
+
+@observe()
+def analyse_news_relevance(
+    raw_content: str,
+    question: str,
+    date_of_interest: datetime,
+    model: str,
+    temperature: float,
+) -> RelevantNewsAnalysis:
+    """
+    Analyse whether the news contains new (relative to the given date)
+    information relevant to the given question.
+    """
+    parser = PydanticOutputParser(pydantic_object=RelevantNewsAnalysis)
+    prompt = PromptTemplate(
+        template=SUMMARISE_RELEVANT_NEWS_PROMPT_TEMPLATE,
+        input_variables=["question", "date_of_interest", "raw_content"],
+        partial_variables={"format_instructions": parser.get_format_instructions()},
+    )
+    llm = ChatOpenAI(
+        temperature=temperature,
+        model=model,
+        api_key=APIKeys().openai_api_key_secretstr_v1,
+    )
+    chain = prompt | llm | parser
+
+    relevant_news_analysis: RelevantNewsAnalysis = chain.invoke(
+        {
+            "raw_content": raw_content,
+            "question": question,
+            "date_of_interest": str(date_of_interest),
+        },
+        config=get_langfuse_langchain_config(),
+    )
+    return relevant_news_analysis
+
+
+@observe()
+def get_certified_relevant_news_since(
+    question: str,
+    days_ago: int,
+    tavily_storage: TavilyStorage | None = None,
+) -> RelevantNews | None:
+    """
+    Get relevant news since a given date for a given question. Retrieves
+    possibly relevant news from tavily, then checks that it is relevant via
+    an LLM call.
+    """
+    results = get_relevant_news_since(
+        question=question,
+        days_ago=days_ago,
+        score_threshold=0.0,  # Be conservative to avoid missing relevant information
+        max_results=3,  # A tradeoff between cost and quality. 3 seems to be a good balance.
+        tavily_storage=tavily_storage,
+    )
+
+    # Sort results by descending 'relevance score' to maximise the chance of
+    # finding relevant news early
+    results = sorted(
+        results,
+        key=lambda result: result.score,
+        reverse=True,
+    )
+
+    for result in results:
+        relevant_news_analysis = analyse_news_relevance(
+            raw_content=check_not_none(result.raw_content),
+            question=question,
+            date_of_interest=utcnow() - timedelta(days=days_ago),
+            model="gpt-4o",  # 4o-mini isn't good enough, 1o and 1o-mini are too expensive
+            temperature=0.0,
+        )
+
+        # Return first relevant news found
+        if relevant_news_analysis.contains_relevant_news:
+            return RelevantNews.from_tavily_result_and_analysis(
+                question=question,
+                days_ago=days_ago,
+                tavily_result=result,
+                relevant_news_analysis=relevant_news_analysis,
+            )
+
+    # No relevant news found
+    return None
+
+
+def get_certified_relevant_news_since_cached(
+    question: str,
+    days_ago: int,
+    cache: RelevantNewsResponseCache,
+    tavily_storage: TavilyStorage | None = None,
+) -> RelevantNews | None:
+    cached = cache.find(question=question, days_ago=days_ago)
+
+    if isinstance(cached, NoRelevantNews):
+        return None
+    elif cached is None:
+        relevant_news = get_certified_relevant_news_since(
+            question=question,
+            days_ago=days_ago,
+            tavily_storage=tavily_storage,
+        )
+        cache.save(
+            question=question,
+            days_ago=days_ago,
+            relevant_news=relevant_news,
+        )
+        return relevant_news
+    else:
+        return cached

prediction_market_agent_tooling/tools/relevant_news_analysis/relevant_news_cache.py

@@ -0,0 +1,90 @@
+from datetime import datetime, timedelta
+
+from pydantic import ValidationError
+from sqlmodel import Field, Session, SQLModel, create_engine, desc, select
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.tools.relevant_news_analysis.data_models import (
+    NoRelevantNews,
+    RelevantNews,
+)
+from prediction_market_agent_tooling.tools.utils import utcnow
+
+
+class RelevantNewsCacheModel(SQLModel, table=True):
+    __tablename__ = "relevant_news_response_cache"
+    __table_args__ = {"extend_existing": True}
+    id: int | None = Field(default=None, primary_key=True)
+    question: str = Field(index=True)
+    datetime_: datetime = Field(index=True)
+    days_ago: int
+    json_dump: str | None
+
+
+class RelevantNewsResponseCache:
+    def __init__(self, sqlalchemy_db_url: str | None = None):
+        self.engine = create_engine(
+            sqlalchemy_db_url
+            if sqlalchemy_db_url
+            else APIKeys().sqlalchemy_db_url.get_secret_value()
+        )
+        self._initialize_db()
+
+    def _initialize_db(self) -> None:
+        """
+        Creates the tables if they don't exist
+        """
+        with self.engine.connect() as conn:
+            SQLModel.metadata.create_all(
+                conn,
+                tables=[SQLModel.metadata.tables[RelevantNewsCacheModel.__tablename__]],
+            )
+
+    def find(
+        self,
+        question: str,
+        days_ago: int,
+    ) -> RelevantNews | NoRelevantNews | None:
+        with Session(self.engine) as session:
+            query = (
+                select(RelevantNewsCacheModel)
+                .where(RelevantNewsCacheModel.question == question)
+                .where(RelevantNewsCacheModel.days_ago <= days_ago)
+                .where(
+                    RelevantNewsCacheModel.datetime_ >= utcnow() - timedelta(days=1)
+                )  # Cache entries expire after 1 day
+            )
+            item = session.exec(
+                query.order_by(desc(RelevantNewsCacheModel.datetime_))
+            ).first()
+
+            if item is None:
+                return None
+            else:
+                if item.json_dump is None:
+                    return NoRelevantNews()
+                else:
+                    try:
+                        return RelevantNews.model_validate_json(item.json_dump)
+                    except ValidationError as e:
+                        logger.error(
+                            f"Error deserializing RelevantNews from cache for {question=}, {days_ago=} and {item=}: {e}"
+                        )
+                        return None
+
+    def save(
+        self,
+        question: str,
+        days_ago: int,
+        relevant_news: RelevantNews | None,
+    ) -> None:
+        with Session(self.engine) as session:
+            cached = RelevantNewsCacheModel(
+                question=question,
+                days_ago=days_ago,
+                datetime_=utcnow(),  # Assumes that the cache is being updated at the time the news is found
+                json_dump=relevant_news.model_dump_json() if relevant_news else None,
+            )
+            session.add(cached)
+            session.commit()

prediction_market_agent_tooling/tools/safe.py

@@ -1,16 +1,16 @@
 from eth_account.signers.local import LocalAccount
 from eth_typing import ChecksumAddress
-from gnosis.eth import EthereumClient
-from gnosis.eth.constants import NULL_ADDRESS
-from gnosis.eth.contracts import get_safe_V1_4_1_contract
-from gnosis.safe.proxy_factory import ProxyFactoryV141
-from gnosis.safe.safe import Safe
 from safe_cli.safe_addresses import (
     get_default_fallback_handler_address,
     get_proxy_factory_address,
     get_safe_contract_address,
     get_safe_l2_contract_address,
 )
+from safe_eth.eth import EthereumClient
+from safe_eth.eth.constants import NULL_ADDRESS
+from safe_eth.eth.contracts import get_safe_V1_4_1_contract
+from safe_eth.safe.proxy_factory import ProxyFactoryV141
+from safe_eth.safe.safe import SafeV141
 from web3.types import Wei
 
 from prediction_market_agent_tooling.loggers import logger
@@ -87,7 +87,7 @@ def create_safe(
 
     # We ignore mypy below because using the proper class SafeV141 yields an error and mypy
     # doesn't understand that there is a hacky factory method (__new__) on this abstract class.
-    safe_version = Safe(safe_contract_address, ethereum_client).retrieve_version()  # type: ignore
+    safe_version = SafeV141(safe_contract_address, ethereum_client).retrieve_version()
     logger.info(
         f"Safe-master-copy={safe_contract_address} version={safe_version}\n"
         f"Fallback-handler={fallback_handler}\n"

prediction_market_agent_tooling/tools/tavily/tavily_search.py

@@ -129,7 +129,7 @@ def _tavily_search(
     return response
 
 
-def get_related_news_since(
+def get_relevant_news_since(
     question: str,
     days_ago: int,
     score_threshold: float = DEFAULT_SCORE_THRESHOLD,

prediction_market_agent_tooling/tools/web3_utils.py

@@ -5,9 +5,9 @@ import base58
 import tenacity
 from eth_account import Account
 from eth_typing import URI
-from gnosis.eth import EthereumClient
-from gnosis.safe.safe import Safe
 from pydantic.types import SecretStr
+from safe_eth.eth import EthereumClient
+from safe_eth.safe.safe import SafeV141
 from web3 import Web3
 from web3.constants import HASH_ZERO
 from web3.types import AccessList, AccessListEntry, Nonce, TxParams, TxReceipt, Wei
@@ -200,7 +200,7 @@ def send_function_on_contract_tx(
     # Don't retry on `reverted` messages, as they would always fail again.
     retry=tenacity.retry_if_exception_message(match=NOT_REVERTED_ICASE_REGEX_PATTERN),
     wait=tenacity.wait_chain(*[tenacity.wait_fixed(n) for n in range(1, 10)]),
-    stop=tenacity.stop_after_attempt(9),
+    stop=tenacity.stop_after_attempt(5),
     after=lambda x: logger.debug(
         f"send_function_on_contract_tx_using_safe failed, {x.attempt_number=}."
     ),
@@ -219,7 +219,7 @@ def send_function_on_contract_tx_using_safe(
     if not web3.provider.endpoint_uri:  # type: ignore
         raise EnvironmentError("RPC_URL not available in web3 object.")
     ethereum_client = EthereumClient(ethereum_node_url=URI(web3.provider.endpoint_uri))  # type: ignore
-    s = Safe(safe_address, ethereum_client)  # type: ignore
+    s = SafeV141(safe_address, ethereum_client)
     safe_master_copy_address = s.retrieve_master_copy_address()
     eoa_public_key = private_key_to_public_key(from_private_key)
     # See https://ethereum.stackexchange.com/questions/123750/how-to-implement-eip-2930-access-list for details,

{prediction_market_agent_tooling-0.55.0.dist-info → prediction_market_agent_tooling-0.55.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prediction-market-agent-tooling
-Version: 0.55.0
+Version: 0.55.1
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.12
@@ -38,7 +38,7 @@ Requires-Dist: pydantic-settings (>=2.4.0,<3.0.0)
 Requires-Dist: pymongo (>=4.8.0,<5.0.0)
 Requires-Dist: python-dateutil (>=2.9.0.post0,<3.0.0)
 Requires-Dist: safe-cli (>=1.0.0,<2.0.0)
-Requires-Dist: safe-eth-py (>=6.0.0b14,<7.0.0)
+Requires-Dist: safe-eth-py (>=6.0.0b41,<7.0.0)
 Requires-Dist: scikit-learn (>=1.3.1,<2.0.0)
 Requires-Dist: sqlmodel (>=0.0.22,<0.0.23)
 Requires-Dist: streamlit (>=1.31.0,<2.0.0)

{prediction_market_agent_tooling-0.55.0.dist-info → prediction_market_agent_tooling-0.55.1.dist-info}/RECORD

@@ -16,14 +16,15 @@ prediction_market_agent_tooling/benchmark/__init__.py,sha256=47DEQpj8HBSa-_TImW-
 prediction_market_agent_tooling/benchmark/agents.py,sha256=B1-uWdyeN4GGKMWGK_-CcAFJg1m9Y_XuaeIHPB29QR8,3971
 prediction_market_agent_tooling/benchmark/benchmark.py,sha256=MqTiaaJ3cYiOLUVR7OyImLWxcEya3Rl5JyFYW-K0lwM,17097
 prediction_market_agent_tooling/benchmark/utils.py,sha256=D0MfUkVZllmvcU0VOurk9tcKT7JTtwwOp-63zuCBVuc,2880
-prediction_market_agent_tooling/config.py,sha256=WC30Nr16RGueTafA9i67OIB-6KDHZRryhiLPzebg9_I,6740
-prediction_market_agent_tooling/deploy/agent.py,sha256=1a1VPaCA77MhK9wQwX1MjEycareP_NYfsm73YFXwyxY,22222
+prediction_market_agent_tooling/config.py,sha256=114f3V9abaok27p5jX3UVr5b5gRUiSxBIYn8Snid34I,6731
+prediction_market_agent_tooling/deploy/agent.py,sha256=s3XVNeuJ9mtlfsRB1RWLWUR0q9fMoptZqu1u-I6oiws,22420
 prediction_market_agent_tooling/deploy/agent_example.py,sha256=dIIdZashExWk9tOdyDjw87AuUcGyM7jYxNChYrVK2dM,1001
 prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=kMrIE3wMv_IB6nJd_1DmDXDkEZhsXFOgyTd7JZ0gqHI,13068
 prediction_market_agent_tooling/deploy/constants.py,sha256=M5ty8URipYMGe_G-RzxRydK3AFL6CyvmqCraJUrLBnE,82
 prediction_market_agent_tooling/deploy/gcp/deploy.py,sha256=CYUgnfy-9XVk04kkxA_5yp0GE9Mw5caYqlFUZQ2j3ks,3739
 prediction_market_agent_tooling/deploy/gcp/kubernetes_models.py,sha256=OsPboCFGiZKsvGyntGZHwdqPlLTthITkNF5rJFvGgU8,2582
 prediction_market_agent_tooling/deploy/gcp/utils.py,sha256=oyW0jgrUT2Tr49c7GlpcMsYNQjoCSOcWis3q-MmVAhU,6089
+prediction_market_agent_tooling/deploy/trade_interval.py,sha256=Xk9j45alQ_vrasGvsNyuW70XHIQ7wfvjoxNR3F6HYCw,1155
 prediction_market_agent_tooling/gtypes.py,sha256=tqp03PyY0Yhievl4XELfwAn0xOoecaTvBZ1Co6b-A7o,2541
 prediction_market_agent_tooling/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/jobs/jobs.py,sha256=I07yh0GJ-xhlvQaOUQB8xlSnihhcbU2c7DZ4ZND14c0,1246
@@ -85,16 +86,19 @@ prediction_market_agent_tooling/tools/langfuse_.py,sha256=jI_4ROxqo41CCnWGS1vN_A
 prediction_market_agent_tooling/tools/langfuse_client_utils.py,sha256=B0PhAQyviFnVbtOCYMxYmcCn66cu9nbqAOIAZcdgiRI,5771
 prediction_market_agent_tooling/tools/omen/reality_accuracy.py,sha256=M1SF7iSW1gVlQSTskdVFTn09uPLST23YeipVIWj54io,2236
 prediction_market_agent_tooling/tools/parallelism.py,sha256=6Gou0hbjtMZrYvxjTDFUDZuxmE2nqZVbb6hkg1hF82A,1022
-prediction_market_agent_tooling/tools/safe.py,sha256=h0xOO0eNtitClf0fPkn-0oTc6A_bflDTee98V_aiV-A,5195
+prediction_market_agent_tooling/tools/relevant_news_analysis/data_models.py,sha256=95l84aztFaxcRLLcRQ46yKJbIlOEuDAbIGLouyliDzA,1316
+prediction_market_agent_tooling/tools/relevant_news_analysis/relevant_news_analysis.py,sha256=OWLzwCbQS2b9hjwTRXTOjjplWXcGXFf3yjKEeK4kGbQ,5720
+prediction_market_agent_tooling/tools/relevant_news_analysis/relevant_news_cache.py,sha256=2yxtBIDyMT_6CsTpZyuIv_2dy2B9WgEOaTT1fSloBu0,3223
+prediction_market_agent_tooling/tools/safe.py,sha256=9vxGGLvSPnfy-sxUFDpBTe8omqpGXP7MzvGPp6bRxrU,5197
 prediction_market_agent_tooling/tools/singleton.py,sha256=CiIELUiI-OeS7U7eeHEt0rnVhtQGzwoUdAgn_7u_GBM,729
 prediction_market_agent_tooling/tools/streamlit_user_login.py,sha256=NXEqfjT9Lc9QtliwSGRASIz1opjQ7Btme43H4qJbzgE,3010
 prediction_market_agent_tooling/tools/tavily/tavily_models.py,sha256=Rz4tZzwCRzPaq49SFT33SCRQrqHXtqWdD9ajb2tGCWc,2723
-prediction_market_agent_tooling/tools/tavily/tavily_search.py,sha256=inGgWo_TFLA7Q0agYx2MYdEsh659oIdovQMniiG_Q20,4895
+prediction_market_agent_tooling/tools/tavily/tavily_search.py,sha256=UPSp0S5Sql52X6UlU2Ki_iO-gmDJSMs5enn9AV_IZRM,4896
 prediction_market_agent_tooling/tools/tavily/tavily_storage.py,sha256=t-tZzbCzBBdFedRZDuVBn3A3mIDX8Z5wza6SxWswu_E,4093
 prediction_market_agent_tooling/tools/utils.py,sha256=W-9SqeCKd51BYMRhDjYPQ7lfNO_zE9EvYpmu2r5WXGA,7163
-prediction_market_agent_tooling/tools/web3_utils.py,sha256=dkcjG-LtuaWRh7WEMzRGmZ5B5rsxZTlliFOI6fj-EJ8,11842
-prediction_market_agent_tooling-0.55.0.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.55.0.dist-info/METADATA,sha256=2a-TbhiR5XyBGScQZDd1pV1vzC-LBWt7zFa6WorpmD8,8056
-prediction_market_agent_tooling-0.55.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-prediction_market_agent_tooling-0.55.0.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.55.0.dist-info/RECORD,,
+prediction_market_agent_tooling/tools/web3_utils.py,sha256=44W8siSLNQxeib98bbwAe7V5C609NHNlUuxwuWIRDiY,11838
+prediction_market_agent_tooling-0.55.1.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.55.1.dist-info/METADATA,sha256=chzNuISP7K3sgt_Mj0fFX6bQu9JFkOXTvYgmqaLFcMU,8056
+prediction_market_agent_tooling-0.55.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+prediction_market_agent_tooling-0.55.1.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.55.1.dist-info/RECORD,,