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

prediction_market_agent_tooling/deploy/agent.py

@@ -6,11 +6,12 @@ from enum import Enum
 from functools import cached_property
 
 from pydantic import computed_field
+from pydantic_ai.exceptions import UnexpectedModelBehavior
 
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.deploy.betting_strategy import (
     BettingStrategy,
-    MultiCategoricalMaxAccuracyBettingStrategy,
+    CategoricalMaxAccuracyBettingStrategy,
     TradeType,
 )
 from prediction_market_agent_tooling.deploy.trade_interval import (
@@ -21,9 +22,10 @@ from prediction_market_agent_tooling.gtypes import USD, OutcomeToken, xDai
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
+    ConditionalFilterType,
     FilterBy,
     ProcessedMarket,
-    ProcessedTradedMarket,
+    QuestionType,
     SortBy,
 )
 from prediction_market_agent_tooling.markets.data_models import (
@@ -31,15 +33,10 @@ from prediction_market_agent_tooling.markets.data_models import (
     ExistingPosition,
     PlacedTrade,
     ProbabilisticAnswer,
+    ScalarProbabilisticAnswer,
     Trade,
 )
-from prediction_market_agent_tooling.markets.markets import (
-    MarketType,
-    have_bet_on_market_since,
-)
-from prediction_market_agent_tooling.markets.omen.omen import (
-    send_keeping_token_to_eoa_xdai,
-)
+from prediction_market_agent_tooling.markets.market_type import MarketType
 from prediction_market_agent_tooling.tools.custom_exceptions import (
     CantPayForGasError,
     OutOfFundsError,
@@ -47,12 +44,16 @@ from prediction_market_agent_tooling.tools.custom_exceptions import (
 from prediction_market_agent_tooling.tools.is_invalid import is_invalid
 from prediction_market_agent_tooling.tools.is_predictable import is_predictable_binary
 from prediction_market_agent_tooling.tools.langfuse_ import langfuse_context, observe
+from prediction_market_agent_tooling.tools.rephrase import (
+    rephrase_question_to_unconditional,
+)
 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 (
     DatetimeUTC,
     check_not_none,
+    retry_until_true,
     utcnow,
 )
 
@@ -196,6 +197,7 @@ class DeployablePredictionAgent(DeployableAgent):
     trade_on_markets_created_after: DatetimeUTC | None = None
     get_markets_sort_by: SortBy = SortBy.CLOSING_SOONEST
     get_markets_filter_by: FilterBy = FilterBy.OPEN
+    rephrase_conditional_markets: bool = True
 
     # Agent behaviour when filtering fetched markets
     allow_invalid_questions: bool = False
@@ -205,6 +207,8 @@ class DeployablePredictionAgent(DeployableAgent):
         MINIMUM_NATIVE_TOKEN_IN_EOA_FOR_FEES
     )
 
+    just_warn_on_unexpected_model_behavior: bool = False
+
     # Only Metaculus allows to post predictions without trading (buying/selling of outcome tokens).
     supported_markets: t.Sequence[MarketType] = [MarketType.METACULUS]
 
@@ -219,11 +223,12 @@ class DeployablePredictionAgent(DeployableAgent):
     def initialize_langfuse(self) -> None:
         super().initialize_langfuse()
         # Auto-observe all the methods where it makes sense, so that subclassses don't need to do it manually.
-        self.have_bet_on_market_since = observe()(self.have_bet_on_market_since)  # type: ignore[method-assign]
         self.verify_market = observe()(self.verify_market)  # type: ignore[method-assign]
         self.answer_binary_market = observe()(self.answer_binary_market)  # type: ignore[method-assign]
         self.answer_categorical_market = observe()(self.answer_categorical_market)  # type: ignore[method-assign]
+        self.answer_scalar_market = observe()(self.answer_scalar_market)  # type: ignore[method-assign]
         self.process_market = observe()(self.process_market)  # type: ignore[method-assign]
+        self.rephrase_market_to_unconditional = observe()(self.rephrase_market_to_unconditional)  # type: ignore[method-assign]
 
     def update_langfuse_trace_by_market(
         self, market_type: MarketType, market: AgentMarket
@@ -265,16 +270,13 @@ class DeployablePredictionAgent(DeployableAgent):
                 f"{api_keys=} doesn't have enough operational balance."
             )
 
-    def have_bet_on_market_since(self, market: AgentMarket, since: timedelta) -> bool:
-        return have_bet_on_market_since(keys=APIKeys(), market=market, since=since)
-
     def verify_market(self, market_type: MarketType, market: AgentMarket) -> bool:
         """
         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_trade_interval.get(market=market)
+        if market.have_bet_on_market_since(
+            keys=APIKeys(), since=self.same_market_trade_interval.get(market=market)
         ):
             logger.info(
                 f"Market already bet on within {self.same_market_trade_interval}."
@@ -301,11 +303,44 @@ class DeployablePredictionAgent(DeployableAgent):
 
         return True
 
+    def rephrase_market_to_unconditional(
+        self,
+        market_: AgentMarket,
+    ) -> AgentMarket:
+        """
+        If `rephrase_conditional_markets` is set to True,
+        this method will be used to rephrase the question to account for the parent's market probability in the agent's decision process.
+        """
+        new = market_.model_copy(deep=True)
+
+        if new.parent is not None and new.parent.market.parent is not None:
+            new.parent.market = self.rephrase_market_to_unconditional(new.parent.market)
+
+        rephrased_question = (
+            rephrase_question_to_unconditional(
+                new.question,
+                new.parent.market.question,
+                new.parent.market.outcomes[new.parent.parent_outcome],
+            )
+            if new.parent is not None
+            else new.question
+        )
+
+        new.question = rephrased_question
+        new.parent = None
+
+        return new
+
     def answer_categorical_market(
         self, market: AgentMarket
     ) -> CategoricalProbabilisticAnswer | None:
         raise NotImplementedError("This method must be implemented by the subclass")
 
+    def answer_scalar_market(
+        self, market: AgentMarket
+    ) -> ScalarProbabilisticAnswer | None:
+        raise NotImplementedError("This method must be implemented by the subclass")
+
     def answer_binary_market(self, market: AgentMarket) -> ProbabilisticAnswer | None:
         """
         Answer the binary market.
@@ -328,6 +363,28 @@ class DeployablePredictionAgent(DeployableAgent):
             return True
         return False
 
+    @property
+    def fetch_scalar_markets(self) -> bool:
+        # Check if the subclass has implemented the answer_scalar_market method, if yes, fetch scalar markets as well.
+        if self.answer_scalar_market.__wrapped__.__func__ is not DeployablePredictionAgent.answer_scalar_market:  # type: ignore[attr-defined] # This works just fine, but mypy doesn't know about it for some reason.
+            return True
+        return False
+
+    @property
+    def conditional_filter_type(self) -> ConditionalFilterType:
+        if self.rephrase_conditional_markets:
+            return ConditionalFilterType.ALL
+        return ConditionalFilterType.ONLY_NOT_CONDITIONAL
+
+    @property
+    def agent_question_type(self) -> QuestionType:
+        if self.fetch_scalar_markets:
+            return QuestionType.SCALAR
+        elif self.fetch_categorical_markets:
+            return QuestionType.CATEGORICAL
+        else:
+            return QuestionType.BINARY
+
     def get_markets(
         self,
         market_type: MarketType,
@@ -336,13 +393,15 @@ class DeployablePredictionAgent(DeployableAgent):
         Override this method to customize what markets will fetch for processing.
         """
         cls = market_type.market_class
+
         # Fetch the soonest closing markets to choose from
         available_markets = cls.get_markets(
             limit=self.n_markets_to_fetch,
             sort_by=self.get_markets_sort_by,
             filter_by=self.get_markets_filter_by,
             created_after=self.trade_on_markets_created_after,
-            fetch_categorical_markets=self.fetch_categorical_markets,
+            question_type=self.agent_question_type,
+            conditional_filter_type=self.conditional_filter_type,
         )
         return available_markets
 
@@ -352,15 +411,13 @@ class DeployablePredictionAgent(DeployableAgent):
         """
         Executed before processing of each market.
         """
-        api_keys = APIKeys()
 
         if market_type.is_blockchain_market:
-            # Exchange wxdai back to xdai if the balance is getting low, so we can keep paying for fees.
+            # Ensure we have enough native token balance for transaction fees
             if self.min_balance_to_keep_in_native_currency is not None:
-                send_keeping_token_to_eoa_xdai(
-                    api_keys,
+                market.ensure_min_native_balance(
                     min_required_balance=self.min_balance_to_keep_in_native_currency,
-                    multiplier=3,
+                    multiplier=3.0,
                 )
 
     def build_answer(
@@ -375,12 +432,16 @@ class DeployablePredictionAgent(DeployableAgent):
 
         logger.info(f"Answering market '{market.question}'.")
 
+        if self.rephrase_conditional_markets and market.parent is not None:
+            market = self.rephrase_market_to_unconditional(market)
+
         if market.is_binary:
             try:
                 binary_answer = self.answer_binary_market(market)
                 return (
                     CategoricalProbabilisticAnswer.from_probabilistic_answer(
-                        binary_answer
+                        binary_answer,
+                        market.outcomes,
                     )
                     if binary_answer is not None
                     else None
@@ -389,9 +450,39 @@ class DeployablePredictionAgent(DeployableAgent):
                 logger.info(
                     "answer_binary_market() not implemented, falling back to answer_categorical_market()"
                 )
-
+        elif market.is_scalar:
+            scalar_answer = self.answer_scalar_market(market)
+            return (
+                CategoricalProbabilisticAnswer.from_scalar_answer(
+                    scalar_answer,
+                    market.outcomes,
+                )
+                if scalar_answer is not None
+                else None
+            )
         return self.answer_categorical_market(market)
 
+    def verify_answer_outcomes(
+        self, market: AgentMarket, answer: CategoricalProbabilisticAnswer
+    ) -> None:
+        outcomes_from_prob_map = list(answer.probabilities.keys())
+
+        if any(
+            outcome_from_answer not in market.outcomes
+            for outcome_from_answer in outcomes_from_prob_map
+        ):
+            raise ValueError(
+                f"Some of generated outcomes ({outcomes_from_prob_map=}) in probability map doesn't match with market's outcomes ({market.outcomes=})."
+            )
+
+        if any(
+            market_outcome not in outcomes_from_prob_map
+            for market_outcome in market.outcomes
+        ):
+            logger.warning(
+                f"Some of market's outcomes ({market.outcomes=}) isn't included in the probability map ({outcomes_from_prob_map=})."
+            )
+
     def process_market(
         self,
         market_type: MarketType,
@@ -403,17 +494,28 @@ class DeployablePredictionAgent(DeployableAgent):
             f"Processing market {market.question=} from {market.url=} with liquidity {market.get_liquidity()}."
         )
 
-        answer = self.build_answer(
-            market=market, market_type=market_type, verify_market=verify_market
-        )
+        try:
+            answer = self.build_answer(
+                market=market, market_type=market_type, verify_market=verify_market
+            )
+        except UnexpectedModelBehavior:
+            (
+                logger.warning
+                if self.just_warn_on_unexpected_model_behavior
+                else logger.exception
+            )(f"Unexpected model behaviour in {self.__class__.__name__}.")
+            answer = None
+
+        if answer is not None:
+            self.verify_answer_outcomes(market=market, answer=answer)
 
         processed_market = (
-            ProcessedMarket(answer=answer) if answer is not None else None
+            ProcessedMarket(answer=answer, trades=[]) if answer is not None else None
         )
 
         self.update_langfuse_trace_by_processed_market(market_type, processed_market)
         logger.info(
-            f"Processed market {market.question=} from {market.url=} with {answer=}."
+            f"Processed market {market.question=} from {market.url=} with {processed_market=}."
         )
         return processed_market
 
@@ -523,12 +625,13 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         super().initialize_langfuse()
         # Auto-observe all the methods where it makes sense, so that subclassses don't need to do it manually.
         self.build_trades = observe()(self.build_trades)  # type: ignore[method-assign]
+        self.execute_trades = observe()(self.execute_trades)  # type: ignore[method-assign]
 
     def check_min_required_balance_to_trade(self, market: AgentMarket) -> None:
         api_keys = APIKeys()
 
         # Get the strategy to know how much it will bet.
-        strategy = self.get_betting_strategy(market)
+        strategy = self.get_betting_strategy_supported(market)
         # Have a little bandwidth after the bet.
         min_required_balance_to_trade = strategy.maximum_possible_bet_amount * 1.01
 
@@ -543,8 +646,10 @@ class DeployableTraderAgent(DeployablePredictionAgent):
 
         total_amount = market.get_in_usd(market.get_tiny_bet_amount())
         existing_position = market.get_position(user_id=user_id)
+
         if existing_position and existing_position.total_amount_current > USD(0):
             total_amount += existing_position.total_amount_current
+
         return total_amount
 
     def get_betting_strategy(self, market: AgentMarket) -> BettingStrategy:
@@ -554,7 +659,18 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         Given the market and prediction, agent uses this method to calculate optimal outcome and bet size.
         """
         total_amount = self.get_total_amount_to_bet(market)
-        return MultiCategoricalMaxAccuracyBettingStrategy(bet_amount=total_amount)
+        return CategoricalMaxAccuracyBettingStrategy(max_position_amount=total_amount)
+
+    def get_betting_strategy_supported(self, market: AgentMarket) -> BettingStrategy:
+        """
+        Use this class internally to assert that the configured betting strategy works with the given market.
+        """
+        strategy = self.get_betting_strategy(market=market)
+        if not strategy.is_market_supported(market):
+            raise ValueError(
+                f"Market {market.url} is not supported by the strategy {strategy}."
+            )
+        return strategy
 
     def build_trades(
         self,
@@ -562,36 +678,13 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         answer: CategoricalProbabilisticAnswer,
         existing_position: ExistingPosition | None,
     ) -> list[Trade]:
-        strategy = self.get_betting_strategy(market=market)
+        strategy = self.get_betting_strategy_supported(market=market)
         trades = strategy.calculate_trades(existing_position, answer, market)
         return trades
 
-    def before_process_market(
-        self, market_type: MarketType, market: AgentMarket
-    ) -> None:
-        super().before_process_market(market_type, market)
-        self.check_min_required_balance_to_trade(market)
-
-    def process_market(
-        self,
-        market_type: MarketType,
-        market: AgentMarket,
-        verify_market: bool = True,
-    ) -> ProcessedTradedMarket | None:
-        processed_market = super().process_market(market_type, market, verify_market)
-        if processed_market is None:
-            return None
-
-        api_keys = APIKeys()
-        user_id = market.get_user_id(api_keys=api_keys)
-
-        existing_position = market.get_position(user_id=user_id)
-        trades = self.build_trades(
-            market=market,
-            answer=processed_market.answer,
-            existing_position=existing_position,
-        )
-
+    def execute_trades(
+        self, market: AgentMarket, trades: list[Trade]
+    ) -> list[PlacedTrade]:
         # It can take quite some time before agent processes all the markets, recheck here if the market didn't get closed in the meantime, to not error out completely.
         # Unfortunately, we can not just add some room into closing time of the market while fetching them, because liquidity can be removed at any time by the liquidity providers.
         still_tradeable = market.can_be_traded()
@@ -600,7 +693,8 @@ class DeployableTraderAgent(DeployablePredictionAgent):
                 f"Market {market.question=} ({market.url}) was selected to processing, but is not tradeable anymore."
             )
 
-        placed_trades = []
+        placed_trades: list[PlacedTrade] = []
+
         for trade in trades:
             logger.info(f"Executing trade {trade} on market {market.id} ({market.url})")
 
@@ -612,8 +706,13 @@ class DeployableTraderAgent(DeployablePredictionAgent):
                         )
                     case TradeType.SELL:
                         # Get actual value of the position we are going to sell, and if it's less than we wanted to sell, simply sell all of it.
+                        # In this palce, we expect to have positions, so retry a few times if None are returned, which sometimes happens due to flaky subgraph.
                         current_position = check_not_none(
-                            market.get_position(user_id),
+                            retry_until_true(
+                                lambda x: x is not None and x.total_amount_ot > 0
+                            )(market.get_position)(
+                                market.get_user_id(api_keys=self.api_keys)
+                            ),
                             "Should exists if we are going to sell outcomes.",
                         )
 
@@ -641,7 +740,40 @@ class DeployableTraderAgent(DeployablePredictionAgent):
                     f"Trade execution skipped because, {self.place_trades=} or {still_tradeable=}."
                 )
 
-        traded_market = ProcessedTradedMarket(
+        return placed_trades
+
+    def before_process_market(
+        self, market_type: MarketType, market: AgentMarket
+    ) -> None:
+        super().before_process_market(market_type, market)
+        self.check_min_required_balance_to_trade(market)
+
+    def process_market(
+        self,
+        market_type: MarketType,
+        market: AgentMarket,
+        verify_market: bool = True,
+    ) -> ProcessedMarket | None:
+        processed_market = super().process_market(market_type, market, verify_market)
+        if processed_market is None:
+            return None
+
+        user_id = market.get_user_id(api_keys=self.api_keys)
+
+        try:
+            existing_position = market.get_position(user_id=user_id)
+        except Exception as e:
+            logger.warning(f"Could not get position for user {user_id}, exception {e}")
+            return None
+
+        trades = self.build_trades(
+            market=market,
+            answer=processed_market.answer,
+            existing_position=existing_position,
+        )
+        placed_trades = self.execute_trades(market, trades)
+
+        traded_market = ProcessedMarket(
             answer=processed_market.answer, trades=placed_trades
         )
         logger.info(f"Traded market {market.question=} from {market.url=}.")
@@ -659,10 +791,10 @@ class DeployableTraderAgent(DeployablePredictionAgent):
             market,
             processed_market,
         )
-        if isinstance(processed_market, ProcessedTradedMarket):
-            if self.store_trades:
-                market.store_trades(processed_market, api_keys, self.agent_name)
-            else:
-                logger.info(
-                    f"Trades {processed_market.trades} not stored because {self.store_trades=}."
-                )
+
+        if self.store_trades and processed_market is not None:
+            market.store_trades(processed_market, api_keys, self.agent_name)
+        else:
+            logger.info(
+                f"Trades {processed_market=} not stored because {self.store_trades=}."
+            )

prediction_market_agent_tooling/deploy/agent_example.py

@@ -6,7 +6,7 @@ from prediction_market_agent_tooling.markets.agent_market import AgentMarket, So
 from prediction_market_agent_tooling.markets.data_models import (
     CategoricalProbabilisticAnswer,
 )
-from prediction_market_agent_tooling.markets.markets import MarketType
+from prediction_market_agent_tooling.markets.market_type import MarketType
 
 
 class DeployableCoinFlipAgent(DeployableTraderAgent):