def add_choice_scene_spec(
    model: language_model.LanguageModel,
    game_master_memory: associative_memory.AssociativeMemory,
    scene_name: str,
    buyer: entity_agent_with_logging.EntityAgentWithLogging,
    seller: entity_agent_with_logging.EntityAgentWithLogging,
    clock: game_clock.MultiIntervalClock,
    scene_type_name: str,
    buyer_base_reward: float,
    seller_base_reward: float,
    verbose: bool = False,
) -> tuple[scene_lib.SceneTypeSpec, bargain_payoffs_lib.BargainPayoffs]:
  """Add a minigame scene spec.

  Args:
    model: the language model to use.
    game_master_memory: the game master memory to use.
    scene_name: the name of the scene.
    buyer: the buyer agent.
    seller: the seller agent.
    clock: the clock to use.
    scene_type_name: the name of the scene type.
    buyer_base_reward: how much the buyer can get for selling the fruit later
    seller_base_reward: how much it costs for the seller to buy the fruit
    verbose: whether to print verbose output or not.

  Returns:
    choice_scene_type: the choice scene type.
  """
  action_spec_propose = agent_lib.choice_action_spec(
      call_to_action='What price would {name} propose?:',
      options=('1 coin', '2 coins', '3 coins', '4 coins', '5 coins'),
      tag='choice',
  )
  action_spec_accept = agent_lib.choice_action_spec(
      call_to_action='Would {name} accept the offer?:',
      options=('accept', 'reject'),
      tag='choice',
  )

  action_spec_dict = {
      buyer.name: action_spec_propose,
      seller.name: action_spec_accept,
  }

  bargain_payoffs = bargain_payoffs_lib.BargainPayoffs(
      model=model,
      memory=game_master_memory,
      buyer_base_reward=buyer_base_reward,
      seller_base_reward=seller_base_reward,
      action_to_reward={
          '1 coin': 1.0,
          '2 coins': 2.0,
          '3 coins': 3.0,
          '4 coins': 4.0,
          '5 coins': 5.0,
      },
      buyer=buyer,
      seller=seller,
      resolution_scene=DECISION_SCENE_TYPE,
      acting_player_names=[buyer.name, seller.name],
      outcome_summarization_fn=outcome_summary_fn,
      clock_now=clock.now,
      name='scoring function',
      verbose=verbose,
  )
  decision_env = game_master.GameMaster(
      model=model,
      memory=game_master_memory,
      clock=clock,
      name=scene_name,
      players=[buyer, seller],
      components=[bargain_payoffs],
      action_spec=action_spec_dict,
      update_thought_chain=[bargain_statements],
      randomise_initiative=False,
      player_observes_event=True,
      concurrent_externalities=False,
      verbose=verbose,
  )

  premise = {
      buyer.name: [f'{buyer.name} is ready to make an offer.'],
      seller.name: [f'{seller.name} has to accept or reject the offer.'],
  }

  choice_scene_type = scene_lib.SceneTypeSpec(
      name=scene_type_name,
      premise=premise,
      action_spec=action_spec_dict,
      override_game_master=decision_env,
  )
  return choice_scene_type, bargain_payoffs
Add a minigame scene spec.

  Args:
    model: the language model to use.
    game_master_memory: the game master memory to use.
    scene_name: the name of the scene.
    buyer: the buyer agent.
    seller: the seller agent.
    clock: the clock to use.
    scene_type_name: the name of the scene type.
    buyer_base_reward: how much the buyer can get for selling the fruit later
    seller_base_reward: how much it costs for the seller to buy the fruit
    verbose: whether to print verbose output or not.

  Returns:
    choice_scene_type: the choice scene type.
  
examples/deprecated/modular/environment/haggling.py