prediction-market-agent-tooling 0.39.5__py3-none-any.whl → 0.41.0__py3-none-any.whl

prediction_market_agent_tooling/config.py

@@ -24,6 +24,8 @@ class APIKeys(BaseSettings):
     )
 
     MANIFOLD_API_KEY: t.Optional[SecretStr] = None
+    METACULUS_API_KEY: t.Optional[SecretStr] = None
+    METACULUS_USER_ID: t.Optional[int] = None
     BET_FROM_PRIVATE_KEY: t.Optional[PrivateKey] = None
     SAFE_ADDRESS: t.Optional[ChecksumAddress] = None
     OPENAI_API_KEY: t.Optional[SecretStr] = None
@@ -51,6 +53,18 @@ class APIKeys(BaseSettings):
             self.MANIFOLD_API_KEY, "MANIFOLD_API_KEY missing in the environment."
         )
 
+    @property
+    def metaculus_api_key(self) -> SecretStr:
+        return check_not_none(
+            self.METACULUS_API_KEY, "METACULUS_API_KEY missing in the environment."
+        )
+
+    @property
+    def metaculus_user_id(self) -> int:
+        return check_not_none(
+            self.METACULUS_USER_ID, "METACULUS_USER_ID missing in the environment."
+        )
+
     @property
     def bet_from_private_key(self) -> PrivateKey:
         return check_not_none(
@@ -58,14 +72,14 @@ class APIKeys(BaseSettings):
             "BET_FROM_PRIVATE_KEY missing in the environment.",
         )
 
+    @property
+    def public_key(self) -> ChecksumAddress:
+        return private_key_to_public_key(self.bet_from_private_key)
+
     @property
     def bet_from_address(self) -> ChecksumAddress:
         """If the SAFE is available, we always route transactions via SAFE. Otherwise we use the EOA."""
-        return (
-            self.SAFE_ADDRESS
-            if self.SAFE_ADDRESS
-            else private_key_to_public_key(self.bet_from_private_key)
-        )
+        return self.SAFE_ADDRESS if self.SAFE_ADDRESS else self.public_key
 
     @property
     def openai_api_key(self) -> SecretStr:

prediction_market_agent_tooling/deploy/agent.py

@@ -22,7 +22,7 @@ from prediction_market_agent_tooling.deploy.gcp.utils import (
     gcp_function_is_active,
     gcp_resolve_api_keys_secrets,
 )
-from prediction_market_agent_tooling.gtypes import Probability
+from prediction_market_agent_tooling.gtypes import Probability, xdai_type
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
@@ -36,6 +36,7 @@ from prediction_market_agent_tooling.markets.markets import (
 )
 from prediction_market_agent_tooling.markets.omen.omen import (
     redeem_from_all_user_positions,
+    withdraw_wxdai_to_xdai_to_keep_balance,
 )
 from prediction_market_agent_tooling.monitor.langfuse.langfuse_wrapper import (
     LangfuseWrapper,
@@ -260,9 +261,14 @@ class DeployableTraderAgent(DeployableAgent):
         """
         Executes actions that occur before bets are placed.
         """
+        api_keys = APIKeys()
         if market_type == MarketType.OMEN:
             # Omen is specific, because the user (agent) needs to manually withdraw winnings from the market.
-            redeem_from_all_user_positions(APIKeys())
+            redeem_from_all_user_positions(api_keys)
+            # Exchange wxdai back to xdai if the balance is getting low, so we can keep paying for fees.
+            withdraw_wxdai_to_xdai_to_keep_balance(
+                api_keys, min_required_balance=xdai_type(1), withdraw_multiplier=2
+            )
 
     def process_bets(self, market_type: MarketType) -> None:
         """

prediction_market_agent_tooling/markets/markets.py

@@ -16,6 +16,9 @@ from prediction_market_agent_tooling.markets.manifold.api import (
 from prediction_market_agent_tooling.markets.manifold.manifold import (
     ManifoldAgentMarket,
 )
+from prediction_market_agent_tooling.markets.metaculus.metaculus import (
+    MetaculusAgentMarket,
+)
 from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
 from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
     OmenSubgraphHandler,
@@ -30,6 +33,7 @@ class MarketType(str, Enum):
     MANIFOLD = "manifold"
     OMEN = "omen"
     POLYMARKET = "polymarket"
+    METACULUS = "metaculus"
 
     @property
     def market_class(self) -> type[AgentMarket]:
@@ -42,6 +46,7 @@ MARKET_TYPE_TO_AGENT_MARKET: dict[MarketType, type[AgentMarket]] = {
     MarketType.MANIFOLD: ManifoldAgentMarket,
     MarketType.OMEN: OmenAgentMarket,
     MarketType.POLYMARKET: PolymarketAgentMarket,
+    MarketType.METACULUS: MetaculusAgentMarket,
 }
 
 

prediction_market_agent_tooling/markets/metaculus/api.py

@@ -0,0 +1,97 @@
+from datetime import datetime
+from typing import Union
+
+import requests
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.gtypes import Probability
+from prediction_market_agent_tooling.markets.metaculus.data_models import (
+    MetaculusQuestion,
+)
+from prediction_market_agent_tooling.tools.utils import (
+    response_list_to_model,
+    response_to_model,
+)
+
+METACULUS_API_BASE_URL = "https://www.metaculus.com/api2"
+
+
+def get_auth_headers() -> dict[str, str]:
+    return {"Authorization": f"Token {APIKeys().metaculus_api_key.get_secret_value()}"}
+
+
+def post_question_comment(question_id: str, comment_text: str) -> None:
+    """
+    Post a comment on the question page as the bot user.
+    """
+
+    response = requests.post(
+        f"{METACULUS_API_BASE_URL}/comments/",
+        json={
+            "comment_text": comment_text,
+            "submit_type": "N",
+            "include_latest_prediction": True,
+            "question": question_id,
+        },
+        headers=get_auth_headers(),
+    )
+    response.raise_for_status()
+
+
+def make_prediction(question_id: str, p_yes: Probability) -> None:
+    """
+    Make a prediction for a question.
+    """
+    url = f"{METACULUS_API_BASE_URL}/questions/{question_id}/predict/"
+    response = requests.post(
+        url,
+        json={"prediction": p_yes},
+        headers=get_auth_headers(),
+    )
+    response.raise_for_status()
+
+
+def get_question(question_id: str) -> MetaculusQuestion:
+    """
+    Get all details about a specific question.
+    """
+    url = f"{METACULUS_API_BASE_URL}/questions/{question_id}/"
+    return response_to_model(
+        response=requests.get(url, headers=get_auth_headers()),
+        model=MetaculusQuestion,
+    )
+
+
+def get_questions(
+    limit: int,
+    order_by: str | None = None,
+    offset: int = 0,
+    tournament_id: int | None = None,
+    created_after: datetime | None = None,
+    status: str | None = None,
+) -> list[MetaculusQuestion]:
+    """
+    List detailed metaculus questions (i.e. markets)
+    """
+    url_params: dict[str, Union[int, str]] = {
+        "limit": limit,
+        "offset": offset,
+        "has_group": "false",
+        "forecast_type": "binary",
+        "type": "forecast",
+        "include_description": "true",
+    }
+    if order_by:
+        url_params["order_by"] = order_by
+    if tournament_id:
+        url_params["project"] = tournament_id
+    if created_after:
+        url_params["created_time__gt"] = created_after.isoformat()
+    if status:
+        url_params["status"] = status
+
+    url = f"{METACULUS_API_BASE_URL}/questions/"
+    return response_list_to_model(
+        response=requests.get(url, headers=get_auth_headers(), params=url_params),
+        model=MetaculusQuestion,
+    )

prediction_market_agent_tooling/markets/metaculus/data_models.py

@@ -0,0 +1,90 @@
+from datetime import datetime
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class QuestionType(str, Enum):
+    forecast = "forecast"
+    notebook = "notebook"
+    discussion = "discussion"
+    claim = "claim"
+    group = "group"
+    conditional_group = "conditional_group"
+    multiple_choice = "multiple_choice"
+
+
+class CommunityPrediction(BaseModel):
+    y: list[float]
+    q1: float | None = None
+    q2: float | None = None
+    q3: float | None = None
+
+    @property
+    def p_yes(self) -> float:
+        """
+        q2 corresponds to the median, or 'second quartile' of the distribution.
+
+        If no value is provided (i.e. the question is new and has not been
+        answered yet), we default to 0.5.
+        """
+        return self.q2 if self.q2 is not None else 0.5
+
+
+class Prediction(BaseModel):
+    t: datetime
+    x: float
+
+
+class UserPredictions(BaseModel):
+    id: int
+    predictions: list[Prediction]
+    points_won: float | None = None
+    user: int
+    username: str
+    question: int
+
+
+class CommunityPredictionStats(BaseModel):
+    full: CommunityPrediction
+    unweighted: CommunityPrediction
+
+
+class MetaculusQuestion(BaseModel):
+    """
+    https://www.metaculus.com/api2/schema/redoc/#tag/questions/operation/questions_retrieve
+    """
+
+    active_state: Any
+    url: str
+    page_url: str
+    id: int
+    author: int
+    author_name: str
+    author_id: int
+    title: str
+    title_short: str
+    group_label: str | None = None
+    resolution: int | None
+    resolved_option: int | None
+    created_time: datetime
+    publish_time: datetime | None = None
+    close_time: datetime | None = None
+    effected_close_time: datetime | None
+    resolve_time: datetime | None = None
+    possibilities: dict[Any, Any] | None = None
+    scoring: dict[Any, Any] = {}
+    type: QuestionType | None = None
+    user_perms: Any
+    weekly_movement: float | None
+    weekly_movement_direction: int | None = None
+    cp_reveal_time: datetime | None = None
+    edited_time: datetime
+    last_activity_time: datetime
+    activity: float
+    comment_count: int
+    votes: int
+    community_prediction: CommunityPredictionStats
+    my_predictions: UserPredictions | None = None
+    # TODO add the rest of the fields https://github.com/gnosis/prediction-market-agent-tooling/issues/301

prediction_market_agent_tooling/markets/metaculus/metaculus.py

@@ -0,0 +1,102 @@
+import typing as t
+from datetime import datetime
+
+from prediction_market_agent_tooling.gtypes import Probability
+from prediction_market_agent_tooling.markets.agent_market import (
+    AgentMarket,
+    FilterBy,
+    SortBy,
+)
+from prediction_market_agent_tooling.markets.metaculus.api import (
+    METACULUS_API_BASE_URL,
+    get_questions,
+    make_prediction,
+    post_question_comment,
+)
+from prediction_market_agent_tooling.markets.metaculus.data_models import (
+    MetaculusQuestion,
+)
+
+
+class MetaculusAgentMarket(AgentMarket):
+    """
+    Metaculus' market class that can be used by agents to make predictions.
+    """
+
+    have_predicted: bool
+    base_url: t.ClassVar[str] = METACULUS_API_BASE_URL
+
+    @staticmethod
+    def from_data_model(model: MetaculusQuestion) -> "MetaculusAgentMarket":
+        return MetaculusAgentMarket(
+            id=str(model.id),
+            question=model.title,
+            outcomes=[],
+            resolution=None,
+            current_p_yes=Probability(model.community_prediction.full.p_yes),
+            created_time=model.created_time,
+            close_time=model.close_time,
+            url=model.url,
+            volume=None,
+            have_predicted=model.my_predictions is not None
+            and len(model.my_predictions.predictions) > 0,
+        )
+
+    @staticmethod
+    def get_binary_markets(
+        limit: int,
+        sort_by: SortBy = SortBy.NONE,
+        filter_by: FilterBy = FilterBy.OPEN,
+        created_after: t.Optional[datetime] = None,
+        excluded_questions: set[str] | None = None,
+        tournament_id: int | None = None,
+    ) -> t.Sequence["MetaculusAgentMarket"]:
+        order_by: str | None
+        if sort_by == SortBy.NONE:
+            order_by = None
+        elif sort_by == SortBy.CLOSING_SOONEST:
+            order_by = "-close_time"
+        elif sort_by == SortBy.NEWEST:
+            order_by = "-created_time"
+        else:
+            raise ValueError(f"Unknown sort_by: {sort_by}")
+
+        status: str | None
+        if filter_by == FilterBy.OPEN:
+            status = "open"
+        elif filter_by == FilterBy.RESOLVED:
+            status = "resolved"
+        elif filter_by == FilterBy.NONE:
+            status = None
+        else:
+            raise ValueError(f"Unknown filter_by: {filter_by}")
+
+        if excluded_questions:
+            raise NotImplementedError(
+                "Excluded questions are not suppoerted for Metaculus markets yet."
+            )
+
+        offset = 0
+        question_page_size = 500
+        all_questions = []
+        while True:
+            questions = get_questions(
+                limit=question_page_size,
+                offset=offset,
+                order_by=order_by,
+                created_after=created_after,
+                status=status,
+                tournament_id=tournament_id,
+            )
+            if not questions:
+                break
+            all_questions.extend(questions)
+            offset += question_page_size
+
+            if len(all_questions) >= limit:
+                break
+        return [MetaculusAgentMarket.from_data_model(q) for q in all_questions]
+
+    def submit_prediction(self, p_yes: Probability, reasoning: str) -> None:
+        make_prediction(self.id, p_yes)
+        post_question_comment(self.id, reasoning)

prediction_market_agent_tooling/markets/omen/omen.py

@@ -489,7 +489,11 @@ class OmenAgentMarket(AgentMarket):
 
     @classmethod
     def get_user_url(cls, keys: APIKeys) -> str:
-        return f"https://gnosisscan.io/address/{keys.bet_from_address}"
+        return get_omen_user_url(keys.bet_from_address)
+
+
+def get_omen_user_url(address: ChecksumAddress) -> str:
+    return f"https://gnosisscan.io/address/{address}"
 
 
 def pick_binary_market(
@@ -1000,3 +1004,40 @@ def get_binary_market_p_yes_history(market: OmenAgentMarket) -> list[Probability
             )
 
     return history
+
+
+def withdraw_wxdai_to_xdai_to_keep_balance(
+    api_keys: APIKeys,
+    min_required_balance: xDai,
+    withdraw_multiplier: float = 1.0,
+    web3: Web3 | None = None,
+) -> None:
+    """
+    Keeps xDai balance above the minimum required balance by withdrawing wxDai to xDai.
+    Optionally, the amount to withdraw can be multiplied by the `withdraw_multiplier`, which can be useful to keep a buffer.
+    """
+    # xDai needs to be in our wallet where we pay transaction fees, so do not check for Safe's balance.
+    current_balances = get_balances(api_keys.public_key, web3)
+
+    if current_balances.xdai >= min_required_balance:
+        logger.info(
+            f"Current xDai balance {current_balances.xdai} is more or equal than the required minimum balance {min_required_balance}."
+        )
+        return
+
+    need_to_withdraw = xDai(
+        (min_required_balance - current_balances.xdai) * withdraw_multiplier
+    )
+
+    if current_balances.wxdai < need_to_withdraw:
+        raise ValueError(
+            f"Current wxDai balance {current_balances.wxdai} is less than the required minimum wxDai to withdraw {need_to_withdraw}."
+        )
+
+    collateral_token_contract = OmenCollateralTokenContract()
+    collateral_token_contract.withdraw(
+        api_keys=api_keys, amount_wei=xdai_to_wei(need_to_withdraw), web3=web3
+    )
+    logger.info(
+        f"Withdrew {need_to_withdraw} wxDai to keep the balance above the minimum required balance {min_required_balance}."
+    )

prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py

@@ -45,10 +45,7 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
 
     REALITYETH_GRAPH_URL = "https://gateway-arbitrum.network.thegraph.com/api/{graph_api_key}/subgraphs/id/E7ymrCnNcQdAAgLbdFWzGE5mvr5Mb5T9VfT43FqA7bNh"
 
-    # TODO: Switch to arbitrum subgraph once it's published.
-    OMEN_IMAGE_MAPPING_GRAPH_URL = (
-        "https://api.studio.thegraph.com/query/63564/omen-thumbnailmapping/v0.0.3"
-    )
+    OMEN_IMAGE_MAPPING_GRAPH_URL = "https://gateway-arbitrum.network.thegraph.com/api/{graph_api_key}/subgraphs/id/EWN14ciGK53PpUiKSm7kMWQ6G4iz3tDrRLyZ1iXMQEdu"
 
     INVALID_ANSWER = "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
 

prediction_market_agent_tooling/monitor/markets/metaculus.py

@@ -0,0 +1,43 @@
+import typing as t
+
+from google.cloud.functions_v2.types.functions import Function
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.deploy.constants import MARKET_TYPE_KEY
+from prediction_market_agent_tooling.gtypes import DatetimeWithTimezone
+from prediction_market_agent_tooling.markets.data_models import ResolvedBet
+from prediction_market_agent_tooling.markets.markets import MarketType
+from prediction_market_agent_tooling.monitor.monitor import DeployedAgent
+
+
+class DeployedMetaculusAgent(DeployedAgent):
+    user: int
+
+    @property
+    def public_id(self) -> str:
+        return str(self.user)
+
+    def get_resolved_bets(self) -> list[ResolvedBet]:
+        raise NotImplementedError("TODO: Implement to allow betting on Metaculus.")
+
+    @staticmethod
+    def from_api_keys(
+        name: str,
+        start_time: DatetimeWithTimezone,
+        api_keys: APIKeys,
+    ) -> "DeployedMetaculusAgent":
+        return DeployedMetaculusAgent(
+            name=name,
+            start_time=start_time,
+            user=api_keys.metaculus_user_id,
+        )
+
+    @classmethod
+    def from_all_gcp_functions(
+        cls: t.Type["DeployedMetaculusAgent"],
+        filter_: t.Callable[[Function], bool] = lambda function: function.labels[
+            MARKET_TYPE_KEY
+        ]
+        == MarketType.METACULUS.value,
+    ) -> t.Sequence["DeployedMetaculusAgent"]:
+        return super().from_all_gcp_functions(filter_=filter_)

prediction_market_agent_tooling/monitor/monitor_app.py

@@ -13,6 +13,9 @@ from prediction_market_agent_tooling.markets.markets import MarketType
 from prediction_market_agent_tooling.monitor.markets.manifold import (
     DeployedManifoldAgent,
 )
+from prediction_market_agent_tooling.monitor.markets.metaculus import (
+    DeployedMetaculusAgent,
+)
 from prediction_market_agent_tooling.monitor.markets.omen import DeployedOmenAgent
 from prediction_market_agent_tooling.monitor.markets.polymarket import (
     DeployedPolymarketAgent,
@@ -36,6 +39,7 @@ MARKET_TYPE_TO_DEPLOYED_AGENT: dict[MarketType, type[DeployedAgent]] = {
     MarketType.MANIFOLD: DeployedManifoldAgent,
     MarketType.OMEN: DeployedOmenAgent,
     MarketType.POLYMARKET: DeployedPolymarketAgent,
+    MarketType.METACULUS: DeployedMetaculusAgent,
 }
 
 

{prediction_market_agent_tooling-0.39.5.dist-info → prediction_market_agent_tooling-0.41.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prediction-market-agent-tooling
-Version: 0.39.5
+Version: 0.41.0
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.12

{prediction_market_agent_tooling-0.39.5.dist-info → prediction_market_agent_tooling-0.41.0.dist-info}/RECORD

@@ -12,8 +12,8 @@ prediction_market_agent_tooling/benchmark/__init__.py,sha256=47DEQpj8HBSa-_TImW-
 prediction_market_agent_tooling/benchmark/agents.py,sha256=HPIFJvackW110ch3UkktbxhU48gMRVo4gQse84Klhdc,4000
 prediction_market_agent_tooling/benchmark/benchmark.py,sha256=xiHKzZx5GHSsDerFHMZ9j_LXAXnSaITSvv67iPe3MEU,21095
 prediction_market_agent_tooling/benchmark/utils.py,sha256=iS1BzyXcCMfMm1Rx--1QCH0pHvBTblTndcDQFbTUJ2s,2897
-prediction_market_agent_tooling/config.py,sha256=pTeV4mbvPmrS_MzmiBklg05_gtsR3pa9Id5HCS-AzKQ,4519
-prediction_market_agent_tooling/deploy/agent.py,sha256=h33uU97x3DjBy8INONtS1Hc5B-NnNDV6MENeeCp0qoA,10185
+prediction_market_agent_tooling/config.py,sha256=beNwFgOpe30lIFIvwyXKzH86jNzkvqKARosKkrl_mmg,5026
+prediction_market_agent_tooling/deploy/agent.py,sha256=TXuQ0L2-dG0tIrJ7srxD3Hbabe_2gILfdBQI-tkl9Og,10522
 prediction_market_agent_tooling/deploy/agent_example.py,sha256=tqXVA2HSFK3pdZ49tMmta8aKdJFT8JN8WeJ1akjrpBk,909
 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
@@ -29,13 +29,16 @@ prediction_market_agent_tooling/markets/manifold/api.py,sha256=m6qOzDiyQfxj62Eo_
 prediction_market_agent_tooling/markets/manifold/data_models.py,sha256=xoCqxk9cO6MZ_px_SEGYZ8hHyhGh-X6QDC8dDhyF3rk,5302
 prediction_market_agent_tooling/markets/manifold/manifold.py,sha256=EwRL06E2Y_ZAzr8efwS5yD6p6rnykrcBhqmNDUGZ8Aw,4075
 prediction_market_agent_tooling/markets/manifold/utils.py,sha256=cPPFWXm3vCYH1jy7_ctJZuQH9ZDaPL4_AgAYzGWkoow,513
-prediction_market_agent_tooling/markets/markets.py,sha256=w05Oo7yCA2axpCw69Q9y4i9Gcdpht0u5bZGbWqld3rU,2964
+prediction_market_agent_tooling/markets/markets.py,sha256=Hz3E7LJ5HIjCHQtdU5_Bymav2dYT0dDxKOL0i8mV0mg,3142
+prediction_market_agent_tooling/markets/metaculus/api.py,sha256=uE11iNTT5RahJq7S_ZnAYDRsFCVT7dbQejbDH-JoeI4,2759
+prediction_market_agent_tooling/markets/metaculus/data_models.py,sha256=OOCwj6PXyPIDq3jNqp76CqBADD7ax9xJp-Ude39jzOg,2326
+prediction_market_agent_tooling/markets/metaculus/metaculus.py,sha256=KMWksTNFCKxqjeMiuRh5yNarPSv7sH0aDkgeC3fm3Dg,3293
 prediction_market_agent_tooling/markets/omen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/markets/omen/data_models.py,sha256=EXtjmcujx68Xu50BVkYXvLuf_Asx5o65RvFS3ZS6HGs,14405
-prediction_market_agent_tooling/markets/omen/omen.py,sha256=dMun3MvkvEVrBmN2NwCCb1Uq3kd9nePe1FhFBgHHcj0,36868
+prediction_market_agent_tooling/markets/omen/omen.py,sha256=0ua3bv8gc2aRHMg1UnuvqS-i7YE-QVzMJs07XgiR1n8,38445
 prediction_market_agent_tooling/markets/omen/omen_contracts.py,sha256=JGXCO9MIVr-DGyoH2sxReAw7ZDTC_ev0UxDpq1QBv5Q,21854
 prediction_market_agent_tooling/markets/omen/omen_resolving.py,sha256=g77QsQ5WnSI2rzBlX87L_EhWMwobkyXyfRhHQmpAdzo,9012
-prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py,sha256=cwimJjzWw7GNXYj_79ztgJawlwJQzf4Q9BPAtqByRFY,25248
+prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py,sha256=kDbeZ8ImLtBSFz0GoGdCqeC1Xd3_eGMAxvmLFT8kp8Y,25222
 prediction_market_agent_tooling/markets/polymarket/api.py,sha256=HXmA1akA0qDj0m3e-GEvWG8x75pm6BX4H7YJPQcST7I,4767
 prediction_market_agent_tooling/markets/polymarket/data_models.py,sha256=9CJzakyEcsn6DQBK2nOXjOMzTZBLAmK_KqevXvW17DI,4292
 prediction_market_agent_tooling/markets/polymarket/data_models_web.py,sha256=f8SRQy0Rn-gIHSEMrJJAI8H3J7l8lzOLj3aCMe0vJv8,11324
@@ -43,10 +46,11 @@ prediction_market_agent_tooling/markets/polymarket/polymarket.py,sha256=zqGfiUOH
 prediction_market_agent_tooling/markets/polymarket/utils.py,sha256=m4JG6WULh5epCJt4XBMHg0ae5NoVhqlOvAl0A7DR9iM,2023
 prediction_market_agent_tooling/monitor/langfuse/langfuse_wrapper.py,sha256=b6T69YB1x8kSUvW9uRFuSWPLOrXzapZG7m5O5SU0QTQ,895
 prediction_market_agent_tooling/monitor/markets/manifold.py,sha256=GdYpgRX1GahDi-75Mr53jgtEg6nWcs_rHDUkg4o_7dQ,3352
+prediction_market_agent_tooling/monitor/markets/metaculus.py,sha256=S8zeDVN2aA6yvQykQNPb8GUGohczfJuCYt9Ds9ESCzs,1473
 prediction_market_agent_tooling/monitor/markets/omen.py,sha256=jOLPnIbDU9syjnYtHfOb2xa6-Ize3vbplgh-8WWkuT4,3323
 prediction_market_agent_tooling/monitor/markets/polymarket.py,sha256=I9z9aO1wncyGI3a09ihrw17JkeBKjAuMmC0I9pl_9o4,1781
 prediction_market_agent_tooling/monitor/monitor.py,sha256=uJdaEpGWp4VcejoQLF0uOxhV75AhrXNyWPVG38gBeOo,14505
-prediction_market_agent_tooling/monitor/monitor_app.py,sha256=rDxgdDJqSK0ARx0TJFMkS76npkHZJz0__Rp0xTpiRok,4611
+prediction_market_agent_tooling/monitor/monitor_app.py,sha256=THyZ67baByakoOm3hIqWOFOBCzg1ZMb_ILgXQ6y0NwE,4763
 prediction_market_agent_tooling/monitor/monitor_settings.py,sha256=Xiozs3AsufuJ04JOe1vjUri-IAMWHjjmc2ugGGiHNH4,947
 prediction_market_agent_tooling/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/tools/balances.py,sha256=nR8_dSfbm3yTOOmMAwhGlurftEiNo1w1WIVzbskjdmM,837
@@ -69,8 +73,8 @@ prediction_market_agent_tooling/tools/singleton.py,sha256=CiIELUiI-OeS7U7eeHEt0r
 prediction_market_agent_tooling/tools/streamlit_user_login.py,sha256=NXEqfjT9Lc9QtliwSGRASIz1opjQ7Btme43H4qJbzgE,3010
 prediction_market_agent_tooling/tools/utils.py,sha256=-G22UEbCRm59bm1RWFdeF55hRsaxgwZVAHvK32-Ye1g,6190
 prediction_market_agent_tooling/tools/web3_utils.py,sha256=nKRHmdLnWSKd3wpo-cysXGvhhrJ2Yf69sN2FFQfSt6s,10578
-prediction_market_agent_tooling-0.39.5.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.39.5.dist-info/METADATA,sha256=pJlbhUhEMtWTxji9oFxWVINfG5NQlwypKHU0ZYg7G5s,7634
-prediction_market_agent_tooling-0.39.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-prediction_market_agent_tooling-0.39.5.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.39.5.dist-info/RECORD,,
+prediction_market_agent_tooling-0.41.0.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.41.0.dist-info/METADATA,sha256=wYeKmF4ZK5-armVe80q2Lfb0byXJewmwC43HiuNMC6M,7634
+prediction_market_agent_tooling-0.41.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+prediction_market_agent_tooling-0.41.0.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.41.0.dist-info/RECORD,,