prediction-market-agent-tooling 0.65.5__py3-none-any.whl → 0.65.7__py3-none-any.whl

prediction_market_agent_tooling/config.py

@@ -65,6 +65,8 @@ class APIKeys(BaseSettings):
 
     SQLALCHEMY_DB_URL: t.Optional[SecretStr] = None
 
+    PERPLEXITY_API_KEY: t.Optional[SecretStr] = None
+
     ENABLE_CACHE: bool = False
     CACHE_DIR: str = "./.cache"
 
@@ -259,6 +261,12 @@ class APIKeys(BaseSettings):
             if self.model_fields[k].annotation not in SECRET_TYPES and v is not None
         }
 
+    @property
+    def perplexity_api_key(self) -> SecretStr:
+        return check_not_none(
+            self.PERPLEXITY_API_KEY, "PERPLEXITY_API_KEY missing in the environment."
+        )
+
     def model_dump_secrets(self) -> dict[str, t.Any]:
         return {
             k: v.get_secret_value() if isinstance(v, SecretStr) else v

prediction_market_agent_tooling/logprobs_parser.py

@@ -61,7 +61,8 @@ class LogprobsParser:
             (
                 i
                 for i in range(result_start_index, len(logprobs))
-                if logprobs[i]["token"] in {",", '"', ",\n", "\",\n'", '",\n'}
+                if logprobs[i]["token"]
+                in {",", '"', ",\n", "\",\n'", '",\n', '"\n', "\n"}
             ),
             len(logprobs) - 1,
         )

prediction_market_agent_tooling/markets/data_models.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Annotated
+from typing import Annotated, Sequence
 
 from pydantic import BaseModel, BeforeValidator, computed_field
 
@@ -26,6 +26,26 @@ class Resolution(BaseModel):
     def from_answer(answer: OutcomeStr) -> "Resolution":
         return Resolution(outcome=answer, invalid=False)
 
+    def find_outcome_matching_market(
+        self, market_outcomes: Sequence[OutcomeStr]
+    ) -> OutcomeStr | None:
+        """
+        Finds a matching outcome in the provided market outcomes.
+
+        Performs case-insensitive matching between this resolution's outcome
+        and the provided market outcomes.
+
+        """
+
+        if not self.outcome:
+            return None
+
+        normalized_outcome = self.outcome.lower()
+        for outcome in market_outcomes:
+            if outcome.lower() == normalized_outcome:
+                return outcome
+        return None
+
 
 class Bet(BaseModel):
     id: str

prediction_market_agent_tooling/markets/omen/omen_resolving.py

@@ -31,7 +31,7 @@ from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
 from prediction_market_agent_tooling.tools.tokens.main_token import (
     MINIMUM_NATIVE_TOKEN_IN_EOA_FOR_FEES,
 )
-from prediction_market_agent_tooling.tools.utils import utcnow
+from prediction_market_agent_tooling.tools.utils import check_not_none, utcnow
 from prediction_market_agent_tooling.tools.web3_utils import ZERO_BYTES
 
 
@@ -223,7 +223,10 @@ def omen_submit_answer_market_tx(
     And after the period is over, you need to resolve the market using `omen_resolve_market_tx`.
     """
     realitio_contract = OmenRealitioContract()
-    outcome_index = market.outcomes.index(resolution.outcome)
+    outcome_matching_market = check_not_none(
+        resolution.find_outcome_matching_market(market.outcomes)
+    )
+    outcome_index = market.outcomes.index(outcome_matching_market)
     realitio_contract.submit_answer(
         api_keys=api_keys,
         question_id=market.question.id,

prediction_market_agent_tooling/markets/seer/exceptions.py

@@ -0,0 +1,2 @@
+class PriceCalculationError(Exception):
+    """Raised when there's an error discovering prices for a market."""

prediction_market_agent_tooling/markets/seer/price_manager.py

@@ -12,6 +12,9 @@ from prediction_market_agent_tooling.gtypes import (
 )
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.seer.data_models import SeerMarket
+from prediction_market_agent_tooling.markets.seer.exceptions import (
+    PriceCalculationError,
+)
 from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
     SeerSubgraphHandler,
 )
@@ -128,7 +131,7 @@ class PriceManager:
             )
             # It's okay if invalid (last) outcome has price 0, but not the other outcomes.
             if price is None and idx != len(self.seer_market.wrapped_tokens) - 1:
-                raise ValueError(
+                raise PriceCalculationError(
                     f"Couldn't get price for {wrapped_token} for market {self.seer_market.url}."
                 )
             price_data[wrapped_token] = (
@@ -142,7 +145,7 @@ class PriceManager:
             sum(price_data.values(), start=CollateralToken.zero())
             == CollateralToken.zero()
         ):
-            raise ValueError(
+            raise PriceCalculationError(
                 f"All prices for market {self.seer_market.url} are zero. This shouldn't happen."
             )
 

prediction_market_agent_tooling/markets/seer/seer.py

@@ -31,6 +31,9 @@ from prediction_market_agent_tooling.markets.seer.data_models import (
     RedeemParams,
     SeerMarket,
 )
+from prediction_market_agent_tooling.markets.seer.exceptions import (
+    PriceCalculationError,
+)
 from prediction_market_agent_tooling.markets.seer.price_manager import PriceManager
 from prediction_market_agent_tooling.markets.seer.seer_contracts import (
     GnosisRouter,
@@ -275,18 +278,24 @@ class SeerAgentMarket(AgentMarket):
 
     @staticmethod
     def from_data_model_with_subgraph(
-        model: SeerMarket, seer_subgraph: SeerSubgraphHandler
+        model: SeerMarket,
+        seer_subgraph: SeerSubgraphHandler,
+        must_have_prices: bool,
     ) -> t.Optional["SeerAgentMarket"]:
-        p = PriceManager(seer_market=model, seer_subgraph=seer_subgraph)
+        price_manager = PriceManager(seer_market=model, seer_subgraph=seer_subgraph)
 
-        probability_map = p.build_probability_map()
-        if not probability_map:
+        probability_map = {}
+        try:
+            probability_map = price_manager.build_probability_map()
+        except PriceCalculationError as e:
             logger.info(
-                f"probability_map for market {model.id.hex()} could not be calculated. Skipping."
+                f"Error when calculating probabilities for market {model.id.hex()} - {e}"
             )
-            return None
+            if must_have_prices:
+                # Price calculation failed, so don't return the market
+                return None
 
-        return SeerAgentMarket(
+        market = SeerAgentMarket(
             id=model.id.hex(),
             question=model.title,
             creator=model.creator,
@@ -305,6 +314,8 @@ class SeerAgentMarket(AgentMarket):
             probabilities=probability_map,
         )
 
+        return market
+
     @staticmethod
     def get_markets(
         limit: int,
@@ -324,17 +335,25 @@ class SeerAgentMarket(AgentMarket):
 
         # We exclude the None values below because `from_data_model_with_subgraph` can return None, which
         # represents an invalid market.
-        return [
+        seer_agent_markets = [
             market
             for m in markets
             if (
                 market := SeerAgentMarket.from_data_model_with_subgraph(
-                    model=m, seer_subgraph=seer_subgraph
+                    model=m,
+                    seer_subgraph=seer_subgraph,
+                    must_have_prices=filter_by == FilterBy.OPEN,
                 )
             )
             is not None
         ]
 
+        if filter_by == FilterBy.OPEN:
+            # Extra manual filter for liquidity, as subgraph is sometimes unreliable.
+            seer_agent_markets = [m for m in seer_agent_markets if m.has_liquidity()]
+
+        return seer_agent_markets
+
     def get_outcome_str_from_idx(self, outcome_index: int) -> OutcomeStr:
         return self.outcomes[outcome_index]
 

prediction_market_agent_tooling/tools/perplexity/perplexity_client.py

@@ -0,0 +1,86 @@
+from typing import Any, Dict, List, Optional
+
+import httpx
+from pydantic import SecretStr
+
+from prediction_market_agent_tooling.tools.perplexity.perplexity_models import (
+    PerplexityModelSettings,
+    PerplexityRequestParameters,
+    PerplexityResponse,
+)
+
+
+class PerplexityModel:
+    def __init__(
+        self,
+        model_name: str,
+        *,
+        api_key: SecretStr,
+        completition_endpoint: str = "https://api.perplexity.ai/chat/completions",
+    ) -> None:
+        self.model_name = model_name
+        self.api_key = api_key
+        self.completition_endpoint = completition_endpoint
+
+    async def request(
+        self,
+        messages: List[dict[str, str]],
+        model_settings: Optional[PerplexityModelSettings],
+        model_request_parameters: PerplexityRequestParameters,
+    ) -> PerplexityResponse:
+        payload: Dict[str, Any] = {"model": self.model_name, "messages": messages}
+
+        if model_settings:
+            model_settings_dict = model_settings.model_dump()
+            model_settings_dict = {
+                k: v for k, v in model_settings_dict.items() if v is not None
+            }
+            payload.update(model_settings_dict)
+
+        params_dict = model_request_parameters.model_dump()
+        params_dict = {k: v for k, v in params_dict.items() if v is not None}
+
+        # Extract and handle search_context_size specially
+        if "search_context_size" in params_dict:
+            search_context_size = params_dict.pop("search_context_size")
+            payload["web_search_options"] = {"search_context_size": search_context_size}
+
+        # Add remaining Perplexity parameters to payload
+        payload.update(params_dict)
+
+        try:
+            async with httpx.AsyncClient(timeout=180) as client:
+                response = await client.post(
+                    self.completition_endpoint,
+                    headers={
+                        "Authorization": f"Bearer {self.api_key.get_secret_value()}",
+                        "Content-Type": "application/json",
+                    },
+                    json=payload,
+                )
+                response.raise_for_status()
+                result: dict[str, Any] = response.json()
+
+                choices = result.get("choices", [])
+                if not choices:
+                    raise ValueError("Invalid response: no choices")
+
+                content = choices[0].get("message", {}).get("content")
+                if not content:
+                    raise ValueError("Invalid response: no content")
+
+                return PerplexityResponse(
+                    content=content,
+                    citations=result.get("citations", []),
+                    usage=result.get("usage", {}),
+                )
+        except httpx.HTTPStatusError as e:
+            raise ValueError(
+                f"HTTP error from Perplexity API: {e.response.status_code} - {e.response.text}"
+            ) from e
+        except httpx.RequestError as e:
+            raise ValueError(f"Request error to Perplexity API: {str(e)}") from e
+        except Exception as e:
+            raise ValueError(
+                f"Unexpected error in Perplexity API request: {str(e)}"
+            ) from e

prediction_market_agent_tooling/tools/perplexity/perplexity_models.py

@@ -0,0 +1,26 @@
+from typing import Any, List, Literal, Optional
+
+from pydantic import BaseModel
+
+
+class PerplexityRequestParameters(BaseModel):
+    search_context_size: Optional[Literal["low", "medium", "high"]]
+    search_recency_filter: Optional[Literal["any", "day", "week", "month", "year"]]
+    search_return_related_questions: Optional[bool]
+    search_domain_filter: Optional[List[str]]
+    search_after_date_filter: Optional[str]
+    search_before_date_filter: Optional[str]
+
+
+class PerplexityResponse(BaseModel):
+    content: str
+    citations: list[str]
+    usage: dict[str, Any]
+
+
+class PerplexityModelSettings(BaseModel):
+    max_tokens: Optional[int] = None
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    frequency_penalty: Optional[float] = None
+    presence_penalty: Optional[float] = None

prediction_market_agent_tooling/tools/perplexity/perplexity_search.py

@@ -0,0 +1,73 @@
+import asyncio
+import typing as t
+from datetime import date, timedelta
+
+import tenacity
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.tools.caches.db_cache import db_cache
+from prediction_market_agent_tooling.tools.perplexity.perplexity_client import (
+    PerplexityModel,
+)
+from prediction_market_agent_tooling.tools.perplexity.perplexity_models import (
+    PerplexityModelSettings,
+    PerplexityRequestParameters,
+    PerplexityResponse,
+)
+
+SYSTEM_PROMPT = "You are a helpful search assistant. Your task is to provide accurate information based on web searches."
+
+
+@tenacity.retry(stop=tenacity.stop_after_attempt(3), wait=tenacity.wait_fixed(1))
+@db_cache(
+    max_age=timedelta(days=1),
+    ignore_args=["api_keys"],
+    log_error_on_unsavable_data=False,
+)
+def perplexity_search(
+    query: str,
+    api_keys: APIKeys,
+    search_context_size: t.Literal["low", "medium", "high"] = "medium",
+    search_recency_filter: t.Literal["any", "day", "week", "month", "year"]
+    | None = None,
+    search_filter_before_date: date | None = None,
+    search_filter_after_date: date | None = None,
+    search_return_related_questions: bool | None = None,
+    include_domains: list[str] | None = None,
+    temperature: float = 0,
+    model_name: str = "sonar-pro",
+    max_tokens: int = 2048,
+) -> PerplexityResponse:
+    # Create messages in ModelMessage format
+    messages = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": query},
+    ]
+
+    # Define special parameters for the request and create the settings
+    model_settings = PerplexityModelSettings(
+        max_tokens=max_tokens, temperature=temperature
+    )
+
+    # Create a basic request parameters object with required base parameters
+    request_params = PerplexityRequestParameters(
+        search_domain_filter=include_domains,
+        search_after_date_filter=search_filter_after_date.strftime("%Y-%m-%d")
+        if search_filter_after_date
+        else None,
+        search_before_date_filter=search_filter_before_date.strftime("%Y-%m-%d")
+        if search_filter_before_date
+        else None,
+        search_recency_filter=search_recency_filter,
+        search_context_size=search_context_size,
+        search_return_related_questions=search_return_related_questions,
+    )
+
+    model = PerplexityModel(model_name=model_name, api_key=api_keys.perplexity_api_key)
+    return asyncio.run(
+        model.request(
+            messages=messages,
+            model_settings=model_settings,
+            model_request_parameters=request_params,
+        )
+    )

{prediction_market_agent_tooling-0.65.5.dist-info → prediction_market_agent_tooling-0.65.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.65.5
+Version: 0.65.7
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.13

{prediction_market_agent_tooling-0.65.5.dist-info → prediction_market_agent_tooling-0.65.7.dist-info}/RECORD

@@ -23,7 +23,7 @@ prediction_market_agent_tooling/benchmark/agents.py,sha256=zC5tUM6pPTWtqSddOOSYV
 prediction_market_agent_tooling/benchmark/benchmark.py,sha256=KwMZzwise3sgmhdjw7xCgHMmjKHdHqQC-zc9untOLWg,17832
 prediction_market_agent_tooling/benchmark/utils.py,sha256=xQd7p9H08-OtN3iC4QT2i9bkUTmrXa6rxGXeg9yMhgU,2986
 prediction_market_agent_tooling/chains.py,sha256=1qQstoqXMwqwM7k-KH7MjMz8Ei-D83KZByvDbCZpAxs,116
-prediction_market_agent_tooling/config.py,sha256=UyhK6u261tBLVsRwvXJm9C0wy6UrUpfAKH6xk4CSfk8,11535
+prediction_market_agent_tooling/config.py,sha256=-kJfdDr-m0R-tGZ1KRI-hJJk0mXDt142CAlvwaJ2N2I,11778
 prediction_market_agent_tooling/deploy/agent.py,sha256=ddFvBUhB_WVWtuUGkiZNKBME4Hd3AdquVv588c1rpu0,25602
 prediction_market_agent_tooling/deploy/agent_example.py,sha256=yS1fWkHynr9MYGNOM2WsCnRWLPaffY4bOc6bIudrdd4,1377
 prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=YYayGjTKW02d3BUavJ8M3NmFk41oldEM3FHbwppZGRM,17184
@@ -37,12 +37,12 @@ prediction_market_agent_tooling/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeu
 prediction_market_agent_tooling/jobs/jobs_models.py,sha256=DoZ9dlvVhpNrnINiR1uy6YUOsuzI_L-avBt362y5xXM,2467
 prediction_market_agent_tooling/jobs/omen/omen_jobs.py,sha256=qbTZ9HVvu_iP4dDxuvOZxAp6JsRKejvEW2YDYCnRmd4,5039
 prediction_market_agent_tooling/loggers.py,sha256=kFZ1BrI8hvWgZO1vzptFnYiOEDx9Ozs86DA9yF3bSgY,5212
-prediction_market_agent_tooling/logprobs_parser.py,sha256=Du1Yc-fAVSixQX_Zx6KWpgSzI_ZYhv5tS1b8IcOPPr8,4979
+prediction_market_agent_tooling/logprobs_parser.py,sha256=DBlBQtWX8_URXhzTU3YWIPa76Zx3QDHlx1ARqbgJsVI,5008
 prediction_market_agent_tooling/markets/agent_market.py,sha256=smKuMaP1zyTtw31Robbj3ospF03xptWX0EDKPJbHH9I,19070
 prediction_market_agent_tooling/markets/base_subgraph_handler.py,sha256=7RaYO_4qAmQ6ZGM8oPK2-CkiJfKmV9MxM-rJlduaecU,1971
 prediction_market_agent_tooling/markets/blockchain_utils.py,sha256=gZMwCTO-1d2ALXeY7-LP6U4kCpotJ6GMPZwN11kFOfE,2604
 prediction_market_agent_tooling/markets/categorize.py,sha256=orLZlPaHgeREU66m1amxfWikeV77idV4sZDPB8NgSD0,1300
-prediction_market_agent_tooling/markets/data_models.py,sha256=vFlX1iNWJcYZlImPkTOQCp2C0veIO7HuAxe0Wf_S8yg,6952
+prediction_market_agent_tooling/markets/data_models.py,sha256=seifqxjVpzZdVKJQ7a5sKPPUM749EHV80SdI6pVQ3b4,7542
 prediction_market_agent_tooling/markets/manifold/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/markets/manifold/api.py,sha256=tWnjuqvU8pcCuja2B_ynHeds1iiEFc6QWHjeSO_GSxY,7676
 prediction_market_agent_tooling/markets/manifold/data_models.py,sha256=QzRfR2g_3vzCw4azj_lOSKSFAZczjAWlM0lQy2dZry8,6704
@@ -59,7 +59,7 @@ prediction_market_agent_tooling/markets/omen/data_models.py,sha256=0jCxgUEVpaggt
 prediction_market_agent_tooling/markets/omen/omen.py,sha256=jyoAV-E_Qcbqqs4oi7junE3rHTG3kaYLMtIVzEkNC6M,49981
 prediction_market_agent_tooling/markets/omen/omen_constants.py,sha256=D9oflYKafLQiHYtB5sScMHqmXyzM8JP8J0yATmc4SQQ,233
 prediction_market_agent_tooling/markets/omen/omen_contracts.py,sha256=f0dKbdVM2OUTSpkCSZdPtKqeckS2c48j3rjnK8oD3wE,29716
-prediction_market_agent_tooling/markets/omen/omen_resolving.py,sha256=05x-Yb0bUsJSEtsWQLqSHyl4HqLChksIb64OGygN-Rw,10226
+prediction_market_agent_tooling/markets/omen/omen_resolving.py,sha256=h4iK7r57D0EaJqfk_n7ISaJHOB93ALL-fCPI1VztXbQ,10364
 prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py,sha256=149T_tJxK2GFnGCulOlGr2Mwiaa7sa74E4lqYsuCv68,39962
 prediction_market_agent_tooling/markets/polymarket/api.py,sha256=UZ4_TG8ceb9Y-qgsOKs8Qiv8zDt957QkT8IX2c83yqo,4800
 prediction_market_agent_tooling/markets/polymarket/data_models.py,sha256=U1SXTz93FIG3GO1h5BJWSt1hPKn_YAMBeZ3k8IS-ook,4552
@@ -67,8 +67,9 @@ prediction_market_agent_tooling/markets/polymarket/data_models_web.py,sha256=wCw
 prediction_market_agent_tooling/markets/polymarket/polymarket.py,sha256=meAhQ5_gwVDvlSxhGGVAvRB7B47zKLnRvZ-_13tKtwY,3433
 prediction_market_agent_tooling/markets/polymarket/utils.py,sha256=8kTeVjXPcXC6DkDvWYsZQLY7x8DS6CEp_yznSEazsNU,2037
 prediction_market_agent_tooling/markets/seer/data_models.py,sha256=G0i-fnVaK16KWDYVI6w3lvyte6Op7ca_iIC8IfrXmlM,4702
-prediction_market_agent_tooling/markets/seer/price_manager.py,sha256=4hSSDyxSj9po9-tRrdtNvJ2d9v0xXT08Ezgbk1JDE3c,6122
-prediction_market_agent_tooling/markets/seer/seer.py,sha256=5uSKUhyM_3PTguYi9yiD3-E5Famb6M_fayBX1NqebAE,20273
+prediction_market_agent_tooling/markets/seer/exceptions.py,sha256=cEObdjluivD94tgOLzmimR7wgQEOt6SRakrYdhsRQtk,112
+prediction_market_agent_tooling/markets/seer/price_manager.py,sha256=MClY2NGwOV70nZYIcmzXFy6Ogd8NBIq7telQcQ3VcU4,6243
+prediction_market_agent_tooling/markets/seer/seer.py,sha256=9AsfvsCVxNvieDPqGtyjdESzFyPEzDVpTR-4P9mL9Y8,20966
 prediction_market_agent_tooling/markets/seer/seer_contracts.py,sha256=kH9nPXsx6UM5er42g2f3fLvy36sY5JM2f_beXeuNgUc,3790
 prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py,sha256=pJxch9_u0EdiIatQP1-UFClt8UEfMZAXBlk5wDO_ovk,9940
 prediction_market_agent_tooling/markets/seer/subgraph_data_models.py,sha256=0izxS8Mtzonfdl9UqvFVXrdj0hVzieroekXhogfZKCw,1817
@@ -100,6 +101,9 @@ prediction_market_agent_tooling/tools/langfuse_client_utils.py,sha256=6IvsqqNNfB
 prediction_market_agent_tooling/tools/omen/reality_accuracy.py,sha256=M1SF7iSW1gVlQSTskdVFTn09uPLST23YeipVIWj54io,2236
 prediction_market_agent_tooling/tools/omen/sell_positions.py,sha256=Q4oI7_QI3AkyxlH10VvxDahYVrphQa1Wnox2Ce_cf_k,2452
 prediction_market_agent_tooling/tools/parallelism.py,sha256=6Gou0hbjtMZrYvxjTDFUDZuxmE2nqZVbb6hkg1hF82A,1022
+prediction_market_agent_tooling/tools/perplexity/perplexity_client.py,sha256=Oi5a_uaCAPtpTAEEVwD0SXWTsKkhCXOQjCBfa1eAuC0,3215
+prediction_market_agent_tooling/tools/perplexity/perplexity_models.py,sha256=SfeR5FGQ2PqaxG4f4ij50LEnS9f2aeLplVwD7IZQh1s,820
+prediction_market_agent_tooling/tools/perplexity/perplexity_search.py,sha256=Ii-5bqk6DygOCK1G78PDdz2sRTNvFYHVYVl2sajUbY4,2616
 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=r4MdP5uEMlaCwoa2XQZzGq3oZEqnoo9S4dg8uzXfSOY,5473
 prediction_market_agent_tooling/tools/relevant_news_analysis/relevant_news_cache.py,sha256=kNWq92T11Knb9mYBZlMiZUzOpKgCd-5adanylQUMRJA,3085
@@ -116,8 +120,8 @@ prediction_market_agent_tooling/tools/tokens/usd.py,sha256=yuW8iPPtcpP4eLH2nORMD
 prediction_market_agent_tooling/tools/transaction_cache.py,sha256=K5YKNL2_tR10Iw2TD9fuP-CTGpBbZtNdgbd0B_R7pjg,1814
 prediction_market_agent_tooling/tools/utils.py,sha256=Jzpck3_QwShhejhgbAhmNxPSOPQJssBQep0eVemVjZ4,7064
 prediction_market_agent_tooling/tools/web3_utils.py,sha256=zRq-eeBGWt8uUGN9G_WfjmJ0eVvO8aWE9S0Pz_Y6AOA,12342
-prediction_market_agent_tooling-0.65.5.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.65.5.dist-info/METADATA,sha256=tPU9fNidxnBbaRgIYRy-e_lt_NL65wOg00vONLBnQOo,8734
-prediction_market_agent_tooling-0.65.5.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-prediction_market_agent_tooling-0.65.5.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.65.5.dist-info/RECORD,,
+prediction_market_agent_tooling-0.65.7.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.65.7.dist-info/METADATA,sha256=Swm7dO-d5M0d1OqUB21l3QZ8gsrlORPKbG_UDDnZRZo,8734
+prediction_market_agent_tooling-0.65.7.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+prediction_market_agent_tooling-0.65.7.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.65.7.dist-info/RECORD,,