init app

.gitignore

@@ -0,0 +1,234 @@
+# Created by .ignore support plugin (hsz.mobi)
+### macOS template
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+### Python template
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+### JetBrains template
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+### VirtualEnv template
+# Virtualenv
+# http://iamzed.com/2009/05/07/a-primer-on-virtualenv/
+.Python
+[Bb]in
+[Ii]nclude
+[Ll]ib
+[Ll]ib64
+[Ll]ocal
+pyvenv.cfg
+.venv
+pip-selfcheck.json
+
+.idea/
+eden.py
+backup/
+raw/
+runs
+*nohup*
+*.pt
+*.out
+/nlgeval/
+*.pkl
+*.db
+/cache/
+_archived/
+output/
+models/
+*_proc
+lightning_logs/
+wandb/
+.lock
+cjjpy.py
+logs/
+exp/
+*.ipynb
+docs/
+.bashrc
+google-cloud-sdk/
+scripts

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

app.py

@@ -0,0 +1,396 @@
+import os
+import gradio as gr
+from app_modules.presets import *
+from app_modules.overwrites import *
+from app_modules.utils import *
+from src.item_base import create_items
+from src.bidder_base import Bidder
+from src.human_bidder import HumanBidder
+from src.auctioneer_base import Auctioneer
+from auction_workflow import run_auction, make_auction_hash
+from utils import chunks, reset_state_list
+
+
+BIDDER_NUM = 4
+items = create_items('data/items_demo.jsonl')
+
+def auction_loop_app(*args):
+    global items
+
+    bidder_list = args[0]   # gr.State() -> session state
+    items_id = args[1]
+    os.environ['OPENAI_API_KEY'] = args[2] if args[2] != '' else os.environ.get('OPENAI_API_KEY', '')
+    os.environ['ANTHROPIC_API_KEY'] = args[3] if args[3] != '' else os.environ.get('ANTHROPIC_API_KEY', '')
+    thread_num = args[4]
+    item_shuffle = args[5]
+    enable_discount = args[6]
+    min_markup_pct = args[7]
+    args = args[8:]
+    auction_hash = make_auction_hash()
+
+    items_to_bid = [items[i] for i in items_id]
+
+    auctioneer = Auctioneer(enable_discount=enable_discount, min_markup_pct=min_markup_pct)
+    auctioneer.init_items(items_to_bid)
+    if item_shuffle:
+        auctioneer.shuffle_items()
+
+    # must correspond to the order in app's parameters
+    input_keys = [
+        'chatbot', 
+        'model_name', 
+        'desire',
+        'plan_strategy', 
+        'budget', 
+        'correct_belief', 
+        'enable_learning',
+        'temperature', 
+        'overestimate_percent',
+    ]
+    
+    # convert flatten list into a json list
+    input_jsl = []
+    for i, chunk in enumerate(chunks(args, len(input_keys))):
+        js = {'name': f"Bidder {i+1}", 'auction_hash': auction_hash}
+        for k, v in zip(input_keys, chunk):
+            js[k] = v
+        input_jsl.append(js)
+    
+    for js in input_jsl:
+        js.pop('chatbot')
+        if 'human' in js['model_name']:
+            bidder_list.append(HumanBidder.create(**js))
+        else:
+            bidder_list.append(Bidder.create(**js))
+    
+    yield from run_auction(auction_hash, auctioneer, bidder_list, thread_num, yield_for_demo=True)
+
+
+with open("assets/custom.css", "r", encoding="utf-8") as f:
+    customCSS = f.read()
+
+with gr.Blocks(css=customCSS, theme=small_and_beautiful_theme) as demo:
+    with gr.Row():
+        gr.HTML(title)
+
+    gr.Markdown(description_top)
+
+    with gr.Row():
+        with gr.Column(scale=6):
+            # item_file = gr.File(label="Upload Item File", file_types=[".jsonl"])
+            items_checkbox = gr.CheckboxGroup(
+                choices=[item.info() for item in items[:20]],
+                label="Items in Auction",
+                info="Select the items you want to include in the auction.",
+                value=[item.info() for item in items[:8]],
+                type="index",
+            )
+        
+        with gr.Column(scale=4):
+            with gr.Row():
+                openai_key = gr.Textbox(label="OpenAI API Key", value="", type="password", placeholder="sk-..")
+                anthropic_key = gr.Textbox(label="Anthropic API Key", value="", type="password", placeholder="sk-ant-..")
+            
+            with gr.Row():
+                with gr.Row():
+                    item_shuffle = gr.Checkbox(
+                        label="Shuffle Items", 
+                        value=False, 
+                        info='Shuffle the order of items in the auction.')
+                    enable_discount = gr.Checkbox(
+                        label="Enable Discount",
+                        value=False,
+                        info='When an item fails to sell at auction, it can be auctioned again at a reduced price.')
+                
+                with gr.Column():
+                    min_markup_pct = gr.Slider(
+                        minimum=0.1,
+                        maximum=0.5,
+                        value=0.1,
+                        step=0.1,
+                        interactive=True,
+                        label='Min Increase',
+                        info="The minimum percentage to increase a bid.",
+                    )
+
+                    thread_num = gr.Slider(
+                        minimum=1,
+                        maximum=BIDDER_NUM,
+                        value=min(5, BIDDER_NUM),
+                        step=1,
+                        interactive=True,
+                        label='Thread Number',
+                        info="More threads, faster bidding, but will run into RateLimitError quicker."
+                    )
+
+    with gr.Row():
+        bidder_info_gr = []
+        chatbots = []
+        monitors = []
+        textbox_list = []
+        for i in range(BIDDER_NUM):
+            with gr.Tab(label=f"Bidder {i+1}"):
+                with gr.Row().style(equal_height=True):
+                    with gr.Column(scale=6):
+                        with gr.Row():
+                            chatbot = gr.Chatbot(elem_id="chuanhu_chatbot", height=600, label='Auction Log')
+                        input_box = gr.Textbox(label="Human Bidder Input", interactive=False, placeholder="Please wait a moment before engaging in the auction.", visible=False)
+                        chatbots.append(chatbot)
+                        textbox_list.append(input_box)
+                    with gr.Column(scale=4):
+                        with gr.Tab(label=f'Parameters'):
+                            model_name = gr.Dropdown(
+                                choices=[
+                                    'rule',
+                                    'human',
+                                    'gpt-3.5-turbo-0613',
+                                    'gpt-3.5-turbo-16k-0613',
+                                    'gpt-4-0613',
+                                    # 'claude-instant-1.1',
+                                    'claude-instant-1.2',
+                                    # 'claude-1.3',
+                                    'claude-2.0',
+                                    # 'chat-bison-001',
+                                ], 
+                                value='gpt-3.5-turbo-16k-0613',
+                                label="Model Selection",
+                            )
+                            budget = gr.Number(
+                                value=10000, 
+                                label='Budget ($)'
+                            )
+                            with gr.Row():
+                                plan_strategy = gr.Dropdown(
+                                    choices=[
+                                        'none',
+                                        'static',
+                                        'adaptive',
+                                    ],
+                                    value='adaptive',
+                                    label='Planning Strategy',
+                                    info='None: no plan. Static: plan only once. Adaptive: replan for the remaining items.'
+                                )
+                                desire = gr.Dropdown(
+                                    choices=[
+                                        # 'default',
+                                        'maximize_profit',
+                                        'maximize_items',
+                                        # 'specific_items', 
+                                    ],
+                                    value='maximize_profit',
+                                    label='Desire',
+                                    info='Default desires: spending all the budget, stay within budget. All desires include the default one.',
+                                )
+                            overestimate_percent = gr.Slider(
+                                minimum=-100,
+                                maximum=100,
+                                value=10,
+                                step=10,
+                                interactive=True,
+                                label='Overestimate Percent (%)',
+                                info="Overestimate the true value of items by this percentage.",
+                            )
+                            with gr.Row():
+                                correct_belief = gr.Checkbox(
+                                    label='Correct Wrong Beliefs',
+                                    value=True,
+                                    info='Forceful beliefs correction about self and others.',
+                                )
+                                enable_learning = gr.Checkbox(
+                                    label='Enable Learning',
+                                    value=False,
+                                    info='Learn from past auctions for future guidance. Only for adaptive bidder.',
+                                    visible=False
+                                )
+                            temperature = gr.Slider(
+                                minimum=0.,
+                                maximum=2.0,
+                                value=0.7,
+                                step=0.1,
+                                interactive=True,
+                                label="Temperature",
+                            )
+
+                            # deprecated
+                            # special_items = gr.CheckboxGroup(
+                            #     value = [],
+                            #     label='Special Items',
+                            #     info='Special items add 20% value for you personally.',
+                            #     visible=False,
+                            # )
+                            # hedge_percent = gr.Slider(
+                            #     minimum=0,
+                            #     maximum=100,
+                            #     value=90,
+                            #     step=1,
+                            #     interactive=True,
+                            #     label='Strategy (Hedging %)',
+                            #     info="The maximum percentage of the estimated value to bid on an item.",
+                            #     visible=False
+                            # )
+
+                        with gr.Tab(label='Monitors'):
+                            with gr.Row():
+                                budget_monitor = gr.Number(label='Budget Left ($)', interactive=False)
+                                profit_monitor = gr.Number(label='Profit ($)', interactive=False)
+                            
+                            with gr.Row():
+                                engagement_monitor = gr.Number(
+                                    label='Engagement',
+                                    interactive=False,
+                                    info='The number of times the bidder has bid.'
+                                )
+                                failure_monitor = gr.Number(
+                                    label='Failed Bids', 
+                                    info='Out-of-budget, or less than the previous highest bid.',
+                                    interactive=False
+                                )
+
+                            items_own_monitor = gr.DataFrame(
+                                label='Items Owned',
+                                headers=['Item', 'Bid ($)', 'Value ($)'],
+                                datatype=['str', 'number', 'number'],
+                                interactive=False,
+                            )
+
+                            with gr.Row():
+                                tokens_monitor = gr.Number(
+                                    label='Token Used', 
+                                    interactive=False, 
+                                    info='Tokens used in the last call.'
+                                )
+                                money_monitor = gr.Number(
+                                    label='API Cost ($)', 
+                                    info='Only OpenAI cost for now.',
+                                    interactive=False
+                                )
+                                
+                            plan_change_monitor = gr.DataFrame(
+                                label='Plan Changes',
+                                headers=['Round', 'Changed', 'New Plan'],
+                                datatype=['str', 'bool', 'str'],
+                                interactive=False,
+                            )
+                        
+                            plot_monitor = gr.Plot(
+                                label='Budget-Profit Plot', 
+                                interactive=False
+                            )
+
+                        with gr.Tab(label='Belief Errors'):
+                            with gr.Row():
+                                self_belief_error_cnt_monitor = gr.Number(
+                                    label='Wrong Beliefs of Self', 
+                                    info='Not knowing its own budget, bid items, or won items.',
+                                    interactive=False,
+                                )
+                                other_belief_error_cnt_monitor = gr.Number(
+                                    label='Wrong Beliefs of Others',
+                                    info='Not knowing other bidders\' profits.',
+                                    interactive=False,
+                                )
+                            budget_belief_monitor = gr.DataFrame(
+                                label='Wrong Belief of Budget ($)',
+                                headers=['Round', 'Belief', 'Truth'],
+                                datatype=['str', 'number', 'number'],
+                                interactive=False,
+                            )
+                            profit_belief_monitor = gr.DataFrame(
+                                label='Wrong Belief of Profit ($)',
+                                headers=['Bidder (Round)', 'Belief', 'Truth'],
+                                datatype=['str', 'number', 'number'],
+                                interactive=False,
+                            )
+                            win_bid_belief_monitor = gr.DataFrame(
+                                label='Wrong Belief of Items Won',
+                                headers=['Bidder (Round)', 
+                                'Belief', 'Truth'],
+                                datatype=['str', 'str', 'str'],
+                                interactive=False,
+                            )
+
+                        monitors += [
+                            budget_monitor, 
+                            profit_monitor, 
+                            items_own_monitor, 
+                            tokens_monitor, 
+                            money_monitor,
+                            failure_monitor,
+                            self_belief_error_cnt_monitor,
+                            other_belief_error_cnt_monitor,
+                            engagement_monitor,
+                            plot_monitor,
+                            plan_change_monitor,
+                            budget_belief_monitor,
+                            profit_belief_monitor,
+                            win_bid_belief_monitor,
+                        ]
+
+                bidder_info_gr += [
+                    chatbot,
+                    model_name,
+                    desire,
+                    plan_strategy,
+                    budget,
+                    correct_belief,
+                    enable_learning,
+                    temperature,
+                    overestimate_percent,
+                ]
+    
+    with gr.Row():
+        with gr.Column():
+            startBtn = gr.Button('Start Bidding', variant='primary', interactive=True)
+        with gr.Column():
+            clearBtn = gr.Button('New Auction', variant='secondary', interactive=False)
+        btn_list = [startBtn, clearBtn]
+    
+    with gr.Accordion(label='Bidding Log (click to open)', open=True):
+        with gr.Row():
+            bidding_log = gr.Markdown(value="")
+
+    gr.Markdown(description)
+    
+    bidder_list_state = gr.State([])    # session state
+
+    start_args = dict(
+        fn=auction_loop_app,
+        inputs=[bidder_list_state, items_checkbox, openai_key, anthropic_key, thread_num, item_shuffle, enable_discount, min_markup_pct] + bidder_info_gr,
+        outputs=[bidder_list_state] + chatbots + monitors + [bidding_log] + btn_list + textbox_list, # TODO: handle textbox_list interactivity
+        show_progress=True,
+    )
+    start_event = startBtn.click(**start_args)
+    
+    def bot(user_message, bidder_list, id):
+        if len(bidder_list) > 0:
+            bidder = bidder_list[int(id)]
+            if bidder.need_input:
+                bidder.input_box = user_message
+                bidder.semaphore += 1
+        return '', bidder_list
+    
+    # handle user input from time to time
+    for i in range(len(textbox_list)):
+        _dummy_id = gr.Number(i, visible=False, interactive=False)
+        textbox_list[i].submit(
+            bot, 
+            [textbox_list[i], bidder_list_state, _dummy_id], 
+            [textbox_list[i], bidder_list_state])
+
+    clearBtn.click(reset_state_list, 
+                   inputs=[bidder_list_state] + chatbots + monitors + [bidding_log], 
+                   outputs=[bidder_list_state] + chatbots + monitors + [bidding_log], 
+                   show_progress=True).then(lambda: gr.update(interactive=True), outputs=[startBtn])
+    
+    demo.title = 'Auction Arena'
+
+
+demo.queue(max_size=64, concurrency_count=16).launch(
+    # server_name='0.0.0.0',
+    # ssl_verify=False,
+    # share=True, 
+    # debug=True,
+    show_api=False,
+)
+
+demo.close()

app_modules/overwrites.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+import logging
+
+# from llama_index import Prompt
+from typing import List, Tuple
+# import mdtex2html
+
+from app_modules.presets import *
+from app_modules.utils import *
+
+def compact_text_chunks(self, prompt: Prompt, text_chunks: List[str]) -> List[str]:
+    logging.debug("Compacting text chunks...🚀🚀🚀")
+    combined_str = [c.strip() for c in text_chunks if c.strip()]
+    combined_str = [f"[{index+1}] {c}" for index, c in enumerate(combined_str)]
+    combined_str = "\n\n".join(combined_str)
+    # resplit based on self.max_chunk_overlap
+    text_splitter = self.get_text_splitter_given_prompt(prompt, 1, padding=1)
+    return text_splitter.split_text(combined_str)
+
+
+def postprocess(
+    self, y: List[Tuple[str | None, str | None]]
+) -> List[Tuple[str | None, str | None]]:
+    """
+    Parameters:
+        y: List of tuples representing the message and response pairs. Each message and response should be a string, which may be in Markdown format.
+    Returns:
+        List of tuples representing the message and response. Each message and response will be a string of HTML.
+    """
+    if y is None or y == []:
+        return []
+    temp = []
+    for x in y:
+        user, bot = x
+        if not detect_converted_mark(user):
+            user = convert_asis(user)
+        if not detect_converted_mark(bot):
+            bot = convert_mdtext(bot)
+        temp.append((user, bot))
+    return temp
+
+with open("./assets/custom.js", "r", encoding="utf-8") as f, open("./assets/Kelpy-Codos.js", "r", encoding="utf-8") as f2:
+    customJS = f.read()
+    kelpyCodos = f2.read()
+
+def reload_javascript():
+    print("Reloading javascript...")
+    js = f'<script>{customJS}</script><script>{kelpyCodos}</script>'
+    def template_response(*args, **kwargs):
+        res = GradioTemplateResponseOriginal(*args, **kwargs)
+        res.body = res.body.replace(b'</html>', f'{js}</html>'.encode("utf8"))
+        res.init_headers()
+        return res
+
+    gr.routes.templates.TemplateResponse = template_response
+
+GradioTemplateResponseOriginal = gr.routes.templates.TemplateResponse

app_modules/presets.py

@@ -0,0 +1,78 @@
+import gradio as gr
+
+
+title = """<h1 align="center" style="min-width:200px; margin-top:0;"> <img src="https://raw.githubusercontent.com/jiangjiechen/jiangjiechen.github.io/1f23a6b72b7e0b57a54e31a583c9f668a2b8b4b6/media/icon_hua9f9b78e35233aa477f7219cbf68418f_67044_512x512_fill_lanczos_center_3.png" width="32px" style="display: inline"> Auction Arena </h1>"""
+
+description_top = """\
+<div align="center">
+<p>
+An interactive demo for this paper: <a href="https://auction-arena.github.io">Put Your Money Where Your Mouth Is: Evaluating Strategic Planning and Execution of LLM Agents in an Auction Arena</a>. Details of this work can be found at <a href="https://auction-arena.github.io">this page</a>. You can watch AI vs AI in this auction arena, or you can set `model_name=human` to engage in the arena personally. Please enter your API key before start, otherwise you will have errors (please refresh the page if you do). Feel free to <a href="mailto:[email protected]">contact us</a> if you have any questions!
+</p >
+</div>
+"""
+description = """\
+<div align="center" style="margin:16px 0">
+The demo is built on <a href="https://github.com/GaiZhenbiao/ChuanhuChatGPT">ChuanhuChatGPT</a>.
+</div>
+"""
+
+small_and_beautiful_theme = gr.themes.Soft(
+        primary_hue=gr.themes.Color(
+            c50="#02C160",
+            c100="rgba(2, 193, 96, 0.2)",
+            c200="#02C160",
+            c300="rgba(2, 193, 96, 0.32)",
+            c400="rgba(2, 193, 96, 0.32)",
+            c500="rgba(2, 193, 96, 1.0)",
+            c600="rgba(2, 193, 96, 1.0)",
+            c700="rgba(2, 193, 96, 0.32)",
+            c800="rgba(2, 193, 96, 0.32)",
+            c900="#02C160",
+            c950="#02C160",
+        ),
+        secondary_hue=gr.themes.Color(
+            c50="#576b95",
+            c100="#576b95",
+            c200="#576b95",
+            c300="#576b95",
+            c400="#576b95",
+            c500="#576b95",
+            c600="#576b95",
+            c700="#576b95",
+            c800="#576b95",
+            c900="#576b95",
+            c950="#576b95",
+        ),
+        neutral_hue=gr.themes.Color(
+            name="gray",
+            c50="#f9fafb",
+            c100="#f3f4f6",
+            c200="#e5e7eb",
+            c300="#d1d5db",
+            c400="#B2B2B2",
+            c500="#808080",
+            c600="#636363",
+            c700="#515151",
+            c800="#393939",
+            c900="#272727",
+            c950="#171717",
+        ),
+        radius_size=gr.themes.sizes.radius_sm,
+    ).set(
+        button_primary_background_fill="#06AE56",
+        button_primary_background_fill_dark="#06AE56",
+        button_primary_background_fill_hover="#07C863",
+        button_primary_border_color="#06AE56",
+        button_primary_border_color_dark="#06AE56",
+        button_primary_text_color="#FFFFFF",
+        button_primary_text_color_dark="#FFFFFF",
+        button_secondary_background_fill="#F2F2F2",
+        button_secondary_background_fill_dark="#2B2B2B",
+        button_secondary_text_color="#393939",
+        button_secondary_text_color_dark="#FFFFFF",
+        # background_fill_primary="#F7F7F7",
+        # background_fill_primary_dark="#1F1F1F",
+        block_title_text_color="*primary_500",
+        block_title_background_fill="*primary_100",
+        input_background_fill="#F6F6F6",
+    )

app_modules/utils.py

@@ -0,0 +1,375 @@
+# -*- coding:utf-8 -*-
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Tuple, Type
+import logging
+# import json
+# import os
+# import datetime
+# import hashlib
+# import csv
+# import requests
+import re
+import html
+# import markdown2
+import torch 
+import sys
+import gc
+from pygments.lexers import guess_lexer, ClassNotFound
+
+import gradio as gr
+# from pypinyin import lazy_pinyin
+# import tiktoken
+# import mdtex2html
+# from markdown import markdown
+from pygments import highlight
+from pygments.lexers import guess_lexer,get_lexer_by_name
+from pygments.formatters import HtmlFormatter
+# import transformers
+# from peft import PeftModel
+# from transformers import GenerationConfig, LlamaForCausalLM, LlamaTokenizer
+
+from app_modules.presets import *
+
+# logging.basicConfig(
+#     level=logging.INFO,
+#     format="%(asctime)s [%(levelname)s] [%(filename)s:%(lineno)d] %(message)s",
+# )
+
+
+def markdown_to_html_with_syntax_highlight(md_str):
+    def replacer(match):
+        lang = match.group(1) or "text"
+        code = match.group(2)
+        lang = lang.strip()
+        #print(1,lang)
+        if lang=="text":
+            lexer = guess_lexer(code)
+            lang = lexer.name
+            #print(2,lang)
+        try:
+            lexer = get_lexer_by_name(lang, stripall=True)
+        except ValueError:
+            lexer = get_lexer_by_name("python", stripall=True)
+        formatter = HtmlFormatter()
+        #print(3,lexer.name)
+        highlighted_code = highlight(code, lexer, formatter)
+
+        return f'<pre><code class="{lang}">{highlighted_code}</code></pre>'
+
+    code_block_pattern = r"```(\w+)?\n([\s\S]+?)\n```"
+    md_str = re.sub(code_block_pattern, replacer, md_str, flags=re.MULTILINE)
+
+    html_str = markdown(md_str)
+    return html_str
+
+
+def normalize_markdown(md_text: str) -> str:
+    lines = md_text.split("\n")
+    normalized_lines = []
+    inside_list = False
+
+    for i, line in enumerate(lines):
+        if re.match(r"^(\d+\.|-|\*|\+)\s", line.strip()):
+            if not inside_list and i > 0 and lines[i - 1].strip() != "":
+                normalized_lines.append("")
+            inside_list = True
+            normalized_lines.append(line)
+        elif inside_list and line.strip() == "":
+            if i < len(lines) - 1 and not re.match(
+                r"^(\d+\.|-|\*|\+)\s", lines[i + 1].strip()
+            ):
+                normalized_lines.append(line)
+            continue
+        else:
+            inside_list = False
+            normalized_lines.append(line)
+
+    return "\n".join(normalized_lines)
+
+
+def convert_mdtext(md_text):
+    code_block_pattern = re.compile(r"```(.*?)(?:```|$)", re.DOTALL)
+    inline_code_pattern = re.compile(r"`(.*?)`", re.DOTALL)
+    code_blocks = code_block_pattern.findall(md_text)
+    non_code_parts = code_block_pattern.split(md_text)[::2]
+
+    result = []
+    for non_code, code in zip(non_code_parts, code_blocks + [""]):
+        if non_code.strip():
+            non_code = normalize_markdown(non_code)
+            if inline_code_pattern.search(non_code):
+                result.append(markdown(non_code, extensions=["tables"]))
+            else:
+                result.append(mdtex2html.convert(non_code, extensions=["tables"]))
+        if code.strip():
+            code = f"\n```{code}\n\n```"
+            code = markdown_to_html_with_syntax_highlight(code)
+            result.append(code)
+    result = "".join(result)
+    result += ALREADY_CONVERTED_MARK
+    return result
+
+def convert_asis(userinput):
+    return f"<p style=\"white-space:pre-wrap;\">{html.escape(userinput)}</p>"+ALREADY_CONVERTED_MARK
+
+def detect_converted_mark(userinput):
+    if userinput.endswith(ALREADY_CONVERTED_MARK):
+        return True
+    else:
+        return False
+
+
+
+def detect_language(code):
+    if code.startswith("\n"):
+        first_line = ""
+    else:
+        first_line = code.strip().split("\n", 1)[0]
+    language = first_line.lower() if first_line else ""
+    code_without_language = code[len(first_line) :].lstrip() if first_line else code
+    return language, code_without_language
+
+def convert_to_markdown(text):
+    text = text.replace("$","&#36;")
+    def replace_leading_tabs_and_spaces(line):
+        new_line = []
+        
+        for char in line:
+            if char == "\t":
+                new_line.append("&#9;")
+            elif char == " ":
+                new_line.append("&nbsp;")
+            else:
+                break
+        return "".join(new_line) + line[len(new_line):]
+
+    markdown_text = ""
+    lines = text.split("\n")
+    in_code_block = False
+
+    for line in lines:
+        if in_code_block is False and line.startswith("```"):
+            in_code_block = True
+            markdown_text += f"{line}\n"
+        elif in_code_block is True and line.startswith("```"):
+            in_code_block = False
+            markdown_text += f"{line}\n"
+        elif in_code_block:
+            markdown_text += f"{line}\n"
+        else:
+            line = replace_leading_tabs_and_spaces(line)
+            line = re.sub(r"^(#)", r"\\\1", line)
+            markdown_text += f"{line}  \n"
+
+    return markdown_text
+
+def add_language_tag(text):
+    def detect_language(code_block):
+        try:
+            lexer = guess_lexer(code_block)
+            return lexer.name.lower()
+        except ClassNotFound:
+            return ""
+
+    code_block_pattern = re.compile(r"(```)(\w*\n[^`]+```)", re.MULTILINE)
+
+    def replacement(match):
+        code_block = match.group(2)
+        if match.group(2).startswith("\n"):
+            language = detect_language(code_block)
+            if language:
+                return f"```{language}{code_block}```"
+            else:
+                return f"```\n{code_block}```"
+        else:
+            return match.group(1) + code_block + "```"
+
+    text2 = code_block_pattern.sub(replacement, text)
+    return text2
+
+def delete_last_conversation(chatbot, history):
+    if len(chatbot) > 0:
+        chatbot.pop()
+
+    if len(history) > 0:
+        history.pop()
+        
+    return (
+        chatbot,
+        history,
+        "Delete Done",
+    )
+
+def reset_state():
+    return [], [], "Reset Done"
+
+def reset_textbox():
+    return gr.update(value=""),""
+
+def cancel_outputing():
+    return "Stop Done"
+
+def transfer_input(inputs):
+    textbox = reset_textbox()
+    return (
+        inputs,
+        gr.update(value=""),
+        gr.Button.update(visible=True),
+    )
+
+
+class State:
+    interrupted = False
+
+    def interrupt(self):
+        self.interrupted = True
+
+    def recover(self):
+        self.interrupted = False
+shared_state = State()
+
+
+
+
+
+# Greedy Search
+def greedy_search(input_ids: torch.Tensor,
+                  model: torch.nn.Module,
+                  tokenizer: transformers.PreTrainedTokenizer,
+                  stop_words: list,
+                  max_length: int,
+                  temperature: float = 1.0,
+                  top_p: float = 1.0,
+                  top_k: int = 25) -> Iterator[str]:
+    generated_tokens = []
+    past_key_values = None
+    current_length = 1
+    for i in range(max_length):
+        with torch.no_grad():
+            if past_key_values is None:
+                outputs = model(input_ids)
+            else:
+                outputs = model(input_ids[:, -1:], past_key_values=past_key_values)
+            logits = outputs.logits[:, -1, :]
+            past_key_values = outputs.past_key_values
+
+            # apply temperature
+            logits /= temperature
+    
+            probs = torch.softmax(logits, dim=-1)
+            # apply top_p
+            probs_sort, probs_idx = torch.sort(probs, dim=-1, descending=True)
+            probs_sum = torch.cumsum(probs_sort, dim=-1)
+            mask = probs_sum - probs_sort > top_p
+            probs_sort[mask] = 0.0
+    
+            # apply top_k
+            #if top_k is not None:
+            #    probs_sort1, _ = torch.topk(probs_sort, top_k)
+            #    min_top_probs_sort = torch.min(probs_sort1, dim=-1, keepdim=True).values
+            #    probs_sort = torch.where(probs_sort < min_top_probs_sort, torch.full_like(probs_sort, float(0.0)), probs_sort)
+    
+            probs_sort.div_(probs_sort.sum(dim=-1, keepdim=True))
+            next_token = torch.multinomial(probs_sort, num_samples=1)
+            next_token = torch.gather(probs_idx, -1, next_token)
+    
+            input_ids = torch.cat((input_ids, next_token), dim=-1)
+    
+            generated_tokens.append(next_token[0].item())
+            text = tokenizer.decode(generated_tokens)
+    
+            yield text
+            if any([x in text for x in stop_words]):
+                del past_key_values
+                del logits
+                del probs
+                del probs_sort
+                del probs_idx
+                del probs_sum
+                gc.collect()
+                return 
+
+def generate_prompt_with_history(text,history,tokenizer,max_length=2048):
+    prompt = "The following is a conversation between a human and an AI assistant named Baize (named after a mythical creature in Chinese folklore). Baize is an open-source AI assistant developed by UCSD and Sun Yat-Sen University. The human and the AI assistant take turns chatting. Human statements start with [|Human|] and AI assistant statements start with [|AI|]. The AI assistant always provides responses in as much detail as possible, and in Markdown format. The AI assistant always declines to engage with topics, questions and instructions related to unethical, controversial, or sensitive issues. Complete the transcript in exactly that format.\n[|Human|]Hello!\n[|AI|]Hi!"   
+    history = ["\n[|Human|]{}\n[|AI|]{}".format(x[0],x[1]) for x in history]
+    history.append("\n[|Human|]{}\n[|AI|]".format(text))
+    history_text = ""
+    flag = False
+    for x in history[::-1]:
+        if tokenizer(prompt+history_text+x, return_tensors="pt")['input_ids'].size(-1) <= max_length:
+            history_text = x + history_text
+            flag = True
+        else:
+            break
+    if flag:
+        return  prompt+history_text,tokenizer(prompt+history_text, return_tensors="pt")
+    else:
+        return None
+
+
+def is_stop_word_or_prefix(s: str, stop_words: list) -> bool:
+    for stop_word in stop_words:
+        if s.endswith(stop_word):
+            return True
+        for i in range(1, len(stop_word)):
+            if s.endswith(stop_word[:i]):
+                return True
+    return False
+
+
+
+def load_tokenizer_and_model(base_model,adapter_model=None,load_8bit=False):
+    if torch.cuda.is_available():
+        device = "cuda"
+    else:
+        device = "cpu"
+
+    try:
+        if torch.backends.mps.is_available():
+            device = "mps"
+    except:  # noqa: E722
+        pass
+    tokenizer = LlamaTokenizer.from_pretrained(base_model)
+    if device == "cuda":
+        model = LlamaForCausalLM.from_pretrained(
+            base_model,
+            load_in_8bit=load_8bit,
+            torch_dtype=torch.float16,
+            device_map="auto",
+        )
+        if adapter_model is not None:
+            model = PeftModel.from_pretrained(
+                model,
+                adapter_model,
+                torch_dtype=torch.float16,
+            )
+    elif device == "mps":
+        model = LlamaForCausalLM.from_pretrained(
+            base_model,
+            device_map={"": device},
+            torch_dtype=torch.float16,
+        )
+        if adapter_model is not None:
+            model = PeftModel.from_pretrained(
+                model,
+                adapter_model,
+                device_map={"": device},
+                torch_dtype=torch.float16,
+            )
+    else:
+        model = LlamaForCausalLM.from_pretrained(
+            base_model, device_map={"": device}, low_cpu_mem_usage=True
+        )
+        if adapter_model is not None:
+            model = PeftModel.from_pretrained(
+                model,
+                adapter_model,
+                device_map={"": device},
+            )
+
+    if not load_8bit:
+        model.half()  # seems to fix bugs for some users.
+
+    model.eval()
+    return tokenizer,model,device
+

assets/Kelpy-Codos.js

@@ -0,0 +1,76 @@
+// ==UserScript==
+// @name         Kelpy Codos
+// @namespace    https://github.com/Keldos-Li/Kelpy-Codos
+// @version      1.0.5
+// @author       Keldos; https://keldos.me/
+// @description  Add copy button to PRE tags before CODE tag, for Chuanhu ChatGPT especially. 
+//               Based on Chuanhu ChatGPT version: ac04408 (2023-3-22)
+// @license      GPL-3.0
+// @grant        none
+// ==/UserScript==
+
+(function () {
+    'use strict';
+
+    function addCopyButton(pre) {
+        var code = pre.querySelector('code');
+        if (!code) {
+            return; // 如果没有找到 <code> 元素，则不添加按钮
+        }
+        var firstChild = code.firstChild;
+        if (!firstChild) {
+            return; // 如果 <code> 元素没有子节点，则不添加按钮
+        }
+        var button = document.createElement('button');
+        button.textContent = '\uD83D\uDCCE'; // 使用 📎 符号作为“复制”按钮的文本
+        button.style.position = 'relative';
+        button.style.float = 'right';
+        button.style.fontSize = '1em'; // 可选：调整按钮大小
+        button.style.background = 'none'; // 可选：去掉背景颜色
+        button.style.border = 'none'; // 可选：去掉边框
+        button.style.cursor = 'pointer'; // 可选：显示指针样式
+        button.addEventListener('click', function () {
+            var range = document.createRange();
+            range.selectNodeContents(code);
+            range.setStartBefore(firstChild); // 将范围设置为第一个子节点之前
+            var selection = window.getSelection();
+            selection.removeAllRanges();
+            selection.addRange(range);
+
+            try {
+                var success = document.execCommand('copy');
+                if (success) {
+                    button.textContent = '\u2714';
+                    setTimeout(function () {
+                        button.textContent = '\uD83D\uDCCE'; // 恢复按钮为“复制”
+                    }, 2000);
+                } else {
+                    button.textContent = '\u2716';
+                }
+            } catch (e) {
+                console.error(e);
+                button.textContent = '\u2716';
+            }
+
+            selection.removeAllRanges();
+        });
+        code.insertBefore(button, firstChild); // 将按钮插入到第一个子元素之前
+    }
+
+    function handleNewElements(mutationsList, observer) {
+        for (var mutation of mutationsList) {
+            if (mutation.type === 'childList') {
+                for (var node of mutation.addedNodes) {
+                    if (node.nodeName === 'PRE') {
+                        addCopyButton(node);
+                    }
+                }
+            }
+        }
+    }
+
+    var observer = new MutationObserver(handleNewElements);
+    observer.observe(document.documentElement, { childList: true, subtree: true });
+
+    document.querySelectorAll('pre').forEach(addCopyButton);
+})();

assets/custom.css

@@ -0,0 +1,191 @@
+:root {
+    --chatbot-color-light: #F3F3F3;
+    --chatbot-color-dark: #121111;
+}
+
+/* status_display */
+#status_display {
+    display: flex;
+    min-height: 2.5em;
+    align-items: flex-end;
+    justify-content: flex-end;
+}
+#status_display p {
+    font-size: .85em;
+    font-family: monospace;
+    color: var(--body-text-color-subdued);
+}
+
+
+
+/* usage_display */
+#usage_display {
+    height: 1em;
+}
+#usage_display p{
+    padding: 0 1em;
+    font-size: .85em;
+    font-family: monospace;
+    color: var(--body-text-color-subdued);
+}
+/* list */
+ol:not(.options), ul:not(.options) {
+    padding-inline-start: 2em !important;
+}
+
+/* Thank @Keldos-Li for fixing it */
+/* Light mode (default) */
+#chuanhu_chatbot {
+    background-color: var(--chatbot-color-light) !important;
+    color: #000000 !important;
+}
+[data-testid = "bot"] {
+    background-color: #FFFFFF !important;
+}
+[data-testid = "user"] {
+    background-color: #95EC69 !important;
+}
+
+/* Dark mode */
+.dark #chuanhu_chatbot {
+    background-color: var(--chatbot-color-dark) !important;
+    color: #FFFFFF !important;
+}
+.dark [data-testid = "bot"] {
+    background-color: #2C2C2C !important;
+}
+.dark [data-testid = "user"] {
+    background-color: #26B561 !important;
+}
+
+#chuanhu_chatbot {
+    height: 100%;
+    min-height: 400px;
+}
+
+[class *= "message"] {
+    border-radius: var(--radius-xl) !important;
+    border: none;
+    padding: var(--spacing-xl) !important;
+    font-size: var(--text-md) !important;
+    line-height: var(--line-md) !important;
+    min-height: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl));
+    min-width: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl));
+}
+[data-testid = "bot"] {
+    max-width: 85%;
+    border-bottom-left-radius: 0 !important;
+}
+[data-testid = "user"] {
+    max-width: 85%;
+    width: auto !important;
+    border-bottom-right-radius: 0 !important;
+}
+/* Table */
+table {
+    margin: 1em 0;
+    border-collapse: collapse;
+    empty-cells: show;
+}
+td,th {
+    border: 1.2px solid var(--border-color-primary) !important;
+    padding: 0.2em;
+}
+thead {
+    background-color: rgba(175,184,193,0.2);
+}
+thead th {
+    padding: .5em .2em;
+}
+/* Inline code */
+#chuanhu_chatbot code {
+    display: inline;
+    white-space: break-spaces;
+    border-radius: 6px;
+    margin: 0 2px 0 2px;
+    padding: .2em .4em .1em .4em;
+    background-color: rgba(175,184,193,0.2);
+}
+/* Code block */
+#chuanhu_chatbot pre code {
+    display: block;
+    overflow: auto;
+    white-space: pre;
+    background-color: hsla(0, 0%, 0%, 80%)!important;
+    border-radius: 10px;
+    padding: 1.4em 1.2em 0em 1.4em;
+    margin: 1.2em 2em 1.2em 0.5em;
+    color: #FFF;
+    box-shadow: 6px 6px 16px hsla(0, 0%, 0%, 0.2);
+}
+/* Hightlight */
+#chuanhu_chatbot .highlight { background-color: transparent }
+#chuanhu_chatbot .highlight .hll { background-color: #49483e }
+#chuanhu_chatbot .highlight .c { color: #75715e } /* Comment */
+#chuanhu_chatbot .highlight .err { color: #960050; background-color: #1e0010 } /* Error */
+#chuanhu_chatbot .highlight .k { color: #66d9ef } /* Keyword */
+#chuanhu_chatbot .highlight .l { color: #ae81ff } /* Literal */
+#chuanhu_chatbot .highlight .n { color: #f8f8f2 } /* Name */
+#chuanhu_chatbot .highlight .o { color: #f92672 } /* Operator */
+#chuanhu_chatbot .highlight .p { color: #f8f8f2 } /* Punctuation */
+#chuanhu_chatbot .highlight .ch { color: #75715e } /* Comment.Hashbang */
+#chuanhu_chatbot .highlight .cm { color: #75715e } /* Comment.Multiline */
+#chuanhu_chatbot .highlight .cp { color: #75715e } /* Comment.Preproc */
+#chuanhu_chatbot .highlight .cpf { color: #75715e } /* Comment.PreprocFile */
+#chuanhu_chatbot .highlight .c1 { color: #75715e } /* Comment.Single */
+#chuanhu_chatbot .highlight .cs { color: #75715e } /* Comment.Special */
+#chuanhu_chatbot .highlight .gd { color: #f92672 } /* Generic.Deleted */
+#chuanhu_chatbot .highlight .ge { font-style: italic } /* Generic.Emph */
+#chuanhu_chatbot .highlight .gi { color: #a6e22e } /* Generic.Inserted */
+#chuanhu_chatbot .highlight .gs { font-weight: bold } /* Generic.Strong */
+#chuanhu_chatbot .highlight .gu { color: #75715e } /* Generic.Subheading */
+#chuanhu_chatbot .highlight .kc { color: #66d9ef } /* Keyword.Constant */
+#chuanhu_chatbot .highlight .kd { color: #66d9ef } /* Keyword.Declaration */
+#chuanhu_chatbot .highlight .kn { color: #f92672 } /* Keyword.Namespace */
+#chuanhu_chatbot .highlight .kp { color: #66d9ef } /* Keyword.Pseudo */
+#chuanhu_chatbot .highlight .kr { color: #66d9ef } /* Keyword.Reserved */
+#chuanhu_chatbot .highlight .kt { color: #66d9ef } /* Keyword.Type */
+#chuanhu_chatbot .highlight .ld { color: #e6db74 } /* Literal.Date */
+#chuanhu_chatbot .highlight .m { color: #ae81ff } /* Literal.Number */
+#chuanhu_chatbot .highlight .s { color: #e6db74 } /* Literal.String */
+#chuanhu_chatbot .highlight .na { color: #a6e22e } /* Name.Attribute */
+#chuanhu_chatbot .highlight .nb { color: #f8f8f2 } /* Name.Builtin */
+#chuanhu_chatbot .highlight .nc { color: #a6e22e } /* Name.Class */
+#chuanhu_chatbot .highlight .no { color: #66d9ef } /* Name.Constant */
+#chuanhu_chatbot .highlight .nd { color: #a6e22e } /* Name.Decorator */
+#chuanhu_chatbot .highlight .ni { color: #f8f8f2 } /* Name.Entity */
+#chuanhu_chatbot .highlight .ne { color: #a6e22e } /* Name.Exception */
+#chuanhu_chatbot .highlight .nf { color: #a6e22e } /* Name.Function */
+#chuanhu_chatbot .highlight .nl { color: #f8f8f2 } /* Name.Label */
+#chuanhu_chatbot .highlight .nn { color: #f8f8f2 } /* Name.Namespace */
+#chuanhu_chatbot .highlight .nx { color: #a6e22e } /* Name.Other */
+#chuanhu_chatbot .highlight .py { color: #f8f8f2 } /* Name.Property */
+#chuanhu_chatbot .highlight .nt { color: #f92672 } /* Name.Tag */
+#chuanhu_chatbot .highlight .nv { color: #f8f8f2 } /* Name.Variable */
+#chuanhu_chatbot .highlight .ow { color: #f92672 } /* Operator.Word */
+#chuanhu_chatbot .highlight .w { color: #f8f8f2 } /* Text.Whitespace */
+#chuanhu_chatbot .highlight .mb { color: #ae81ff } /* Literal.Number.Bin */
+#chuanhu_chatbot .highlight .mf { color: #ae81ff } /* Literal.Number.Float */
+#chuanhu_chatbot .highlight .mh { color: #ae81ff } /* Literal.Number.Hex */
+#chuanhu_chatbot .highlight .mi { color: #ae81ff } /* Literal.Number.Integer */
+#chuanhu_chatbot .highlight .mo { color: #ae81ff } /* Literal.Number.Oct */
+#chuanhu_chatbot .highlight .sa { color: #e6db74 } /* Literal.String.Affix */
+#chuanhu_chatbot .highlight .sb { color: #e6db74 } /* Literal.String.Backtick */
+#chuanhu_chatbot .highlight .sc { color: #e6db74 } /* Literal.String.Char */
+#chuanhu_chatbot .highlight .dl { color: #e6db74 } /* Literal.String.Delimiter */
+#chuanhu_chatbot .highlight .sd { color: #e6db74 } /* Literal.String.Doc */
+#chuanhu_chatbot .highlight .s2 { color: #e6db74 } /* Literal.String.Double */
+#chuanhu_chatbot .highlight .se { color: #ae81ff } /* Literal.String.Escape */
+#chuanhu_chatbot .highlight .sh { color: #e6db74 } /* Literal.String.Heredoc */
+#chuanhu_chatbot .highlight .si { color: #e6db74 } /* Literal.String.Interpol */
+#chuanhu_chatbot .highlight .sx { color: #e6db74 } /* Literal.String.Other */
+#chuanhu_chatbot .highlight .sr { color: #e6db74 } /* Literal.String.Regex */
+#chuanhu_chatbot .highlight .s1 { color: #e6db74 } /* Literal.String.Single */
+#chuanhu_chatbot .highlight .ss { color: #e6db74 } /* Literal.String.Symbol */
+#chuanhu_chatbot .highlight .bp { color: #f8f8f2 } /* Name.Builtin.Pseudo */
+#chuanhu_chatbot .highlight .fm { color: #a6e22e } /* Name.Function.Magic */
+#chuanhu_chatbot .highlight .vc { color: #f8f8f2 } /* Name.Variable.Class */
+#chuanhu_chatbot .highlight .vg { color: #f8f8f2 } /* Name.Variable.Global */
+#chuanhu_chatbot .highlight .vi { color: #f8f8f2 } /* Name.Variable.Instance */
+#chuanhu_chatbot .highlight .vm { color: #f8f8f2 } /* Name.Variable.Magic */
+#chuanhu_chatbot .highlight .il { color: #ae81ff } /* Literal.Number.Integer.Long */

assets/custom.js

@@ -0,0 +1 @@
+// custom javascript here

auction_workflow.py

@@ -0,0 +1,293 @@
+import os
+import time
+import gradio as gr
+import ujson as json
+import traceback
+from typing import List
+from tqdm import tqdm
+from src.auctioneer_base import Auctioneer
+from src.bidder_base import Bidder, bidders_to_chatbots, bidding_multithread
+from utils import trace_back
+
+
+LOG_DIR = 'logs'
+enable_gr = gr.update(interactive=True)
+disable_gr = gr.update(interactive=False)
+
+
+def monitor_all(bidder_list: List[Bidder]):
+    return sum([bidder.to_monitors() for bidder in bidder_list], [])
+
+
+def parse_bid_price(auctioneer: Auctioneer, bidder: Bidder, msg: str):
+    # rebid if the message is not parsible into a bid price
+    bid_price = auctioneer.parse_bid(msg)
+    while bid_price is None:
+        re_msg = bidder.bid("You must be clear about your bidding decision, say either \"I'm out!\" or \"I bid $xxx!\". Please rebid.")
+        bid_price = auctioneer.parse_bid(re_msg)
+        print(f"{bidder.name} rebid: {re_msg}")
+    return bid_price
+
+
+def enable_human_box(bidder_list):
+    signals = []
+    for bidder in bidder_list:
+        if 'human' in bidder.model_name and not bidder.withdraw:
+            signals.append(gr.update(interactive=True, visible=True, 
+                                     placeholder="Please bid! Enter \"I'm out\" or \"I bid $xxx\"."))
+        else:
+            signals.append(disable_gr)
+    return signals
+
+
+def disable_all_box(bidder_list):
+    signals = []
+    for bidder in bidder_list:
+        if 'human' in bidder.model_name: 
+            signals.append(gr.update(interactive=False, visible=True, 
+                                     placeholder="Wait a moment to engage in the auction."))
+        else:
+            signals.append(gr.update(interactive=False, visible=False))
+    return signals
+
+
+def run_auction(
+    auction_hash: str, 
+    auctioneer: Auctioneer, 
+    bidder_list: List[Bidder], 
+    thread_num: int, 
+    yield_for_demo=True,
+    log_dir=LOG_DIR,
+    repeat_num=0,
+    memo_file=None):
+    
+    # bidder_list[0].verbose=True
+    
+    if yield_for_demo:
+        chatbot_list = bidders_to_chatbots(bidder_list)
+        yield [bidder_list] + chatbot_list + monitor_all(bidder_list) + [auctioneer.log()] + [disable_gr, disable_gr] + disable_all_box(bidder_list)
+    
+    # ***************** Learn Round ****************
+    for bidder in bidder_list:
+        if bidder.enable_learning and memo_file:
+            # if no prev memo file, then no need to learn.
+            if os.path.exists(memo_file):
+                with open(memo_file) as f:
+                    data = json.load(f)
+                    past_learnings = data['learnings'][bidder.name]
+                    past_auction_log = data['auction_log']
+                    bidder.learn_from_prev_auction(past_learnings, past_auction_log)
+    
+    # ***************** Plan Round *****************
+    # init bidder profit
+    bidder_profit_info = auctioneer.gather_all_status(bidder_list)
+    for bidder in bidder_list:
+        bidder.set_all_bidders_status(bidder_profit_info)
+
+    plan_instructs = [bidder.get_plan_instruct(auctioneer.items) for bidder in bidder_list]
+
+    bidding_multithread(bidder_list, plan_instructs, func_type='plan', thread_num=thread_num)
+    
+    if yield_for_demo:
+        chatbot_list = bidders_to_chatbots(bidder_list)
+        yield [bidder_list] + chatbot_list + monitor_all(bidder_list) + [auctioneer.log()] + [disable_gr, disable_gr] + disable_all_box(bidder_list)
+    
+    bar = tqdm(total=len(auctioneer.items_queue), desc='Auction Progress')
+    while not auctioneer.end_auction():
+        cur_item = auctioneer.present_item()
+        
+        bid_round = 0
+        while True:
+            # ***************** Bid Round ***************** 
+            auctioneer_msg = auctioneer.ask_for_bid(bid_round)
+            _bidder_list = []
+            _bid_instruct_list = []
+            # remove highest bidder and withdrawn bidders
+            for bidder in bidder_list:
+                if bidder is auctioneer.highest_bidder or bidder.withdraw:
+                    bidder.need_input = False
+                    continue
+                else:
+                    bidder.need_input = True    # enable input from demo
+                    instruct = bidder.get_bid_instruct(auctioneer_msg, bid_round)
+                    _bidder_list.append(bidder)
+                    _bid_instruct_list.append(instruct)
+            
+            if yield_for_demo:
+                chatbot_list = bidders_to_chatbots(bidder_list)
+                yield [bidder_list] + chatbot_list + monitor_all(bidder_list) + [auctioneer.log()] + [disable_gr, disable_gr] + enable_human_box(bidder_list)
+            
+            _msgs = bidding_multithread(_bidder_list, _bid_instruct_list, func_type='bid', thread_num=thread_num)
+
+            for i, (msg, bidder) in enumerate(zip(_msgs, _bidder_list)):
+                if bidder.model_name == 'rule':
+                    bid_price = bidder.bid_rule(auctioneer.prev_round_max_bid, auctioneer.min_markup_pct)
+                else:
+                    bid_price = parse_bid_price(auctioneer, bidder, msg)
+
+                # can't bid more than budget or less than previous highest bid
+                while True:
+                    fail_msg = bidder.bid_sanity_check(bid_price, auctioneer.prev_round_max_bid, auctioneer.min_markup_pct)
+                    if fail_msg is None: 
+                        break
+                    else:
+                        bidder.need_input = True   # enable input from demo
+                        auctioneer_msg = auctioneer.ask_for_rebid(fail_msg=fail_msg, bid_price=bid_price)
+                        rebid_instruct = bidder.get_rebid_instruct(auctioneer_msg)
+                        
+                        if yield_for_demo:
+                            chatbot_list = bidders_to_chatbots(bidder_list)
+                            yield [bidder_list] + chatbot_list + monitor_all(bidder_list) + [auctioneer.log()] + [disable_gr, disable_gr] + disable_all_box(bidder_list)
+                        
+                        msg = bidder.rebid_for_failure(rebid_instruct)
+                        bid_price = parse_bid_price(auctioneer, bidder, msg)
+                    
+                    if yield_for_demo:
+                        chatbot_list = bidders_to_chatbots(bidder_list)
+                        yield [bidder_list] + chatbot_list + monitor_all(bidder_list) + [auctioneer.log()] + [disable_gr, disable_gr] + disable_all_box(bidder_list)
+                
+                bidder.set_withdraw(bid_price)
+                auctioneer.record_bid({'bidder': bidder, 'bid': bid_price, 'raw_msg': msg}, bid_round)
+            
+            if yield_for_demo:
+                chatbot_list = bidders_to_chatbots(bidder_list)
+                yield [bidder_list] + chatbot_list + monitor_all(bidder_list) + [auctioneer.log()] + [disable_gr, disable_gr] + disable_all_box(bidder_list)
+            
+            is_sold = auctioneer.check_hammer(bid_round)
+            bid_round += 1
+            if is_sold: 
+                break
+            else:
+                if auctioneer.fail_to_sell and auctioneer.enable_discount:
+                    for bidder in bidder_list:
+                        bidder.set_withdraw(0) # back in the game
+
+        # ***************** Summarize ***************** 
+        summarize_instruct_list = []
+        for bidder in bidder_list:
+            if bidder is auctioneer.highest_bidder:
+                win_lose_msg = bidder.win_bid(cur_item, auctioneer.highest_bid)
+            else:
+                win_lose_msg = bidder.lose_bid(cur_item)
+            msg = bidder.get_summarize_instruct(
+                bidding_history=auctioneer.all_bidding_history_to_string(),
+                hammer_msg=auctioneer.get_hammer_msg(),
+                win_lose_msg=win_lose_msg
+            )
+            summarize_instruct_list.append(msg)
+
+        # record profit information of all bidders for each bidder
+        # (not used in the auction, just for belief tracking evaluation)
+        bidder_profit_info = auctioneer.gather_all_status(bidder_list)
+        for bidder in bidder_list:
+            bidder.set_all_bidders_status(bidder_profit_info)
+        
+        bidding_multithread(bidder_list, summarize_instruct_list, func_type='summarize', thread_num=thread_num)
+        
+        if yield_for_demo:
+            chatbot_list = bidders_to_chatbots(bidder_list)
+            yield [bidder_list] + chatbot_list + monitor_all(bidder_list) + [auctioneer.log()] + [disable_gr, disable_gr] + disable_all_box(bidder_list)
+
+        # ***************** Replan *****************
+        if len(auctioneer.items_queue) > 0:   # no need to replan if all items are sold
+            replan_instruct_list = [bidder.get_replan_instruct(
+                # bidding_history=auctioneer.all_bidding_history_to_string(), 
+                # hammer_msg=auctioneer.get_hammer_msg()
+                ) for bidder in bidder_list]
+            bidding_multithread(bidder_list, replan_instruct_list, func_type='replan', thread_num=thread_num)
+            
+            if yield_for_demo:
+                chatbot_list = bidders_to_chatbots(bidder_list)
+                yield [bidder_list] + chatbot_list + monitor_all(bidder_list) + [auctioneer.log()] + [disable_gr, disable_gr] + disable_all_box(bidder_list)
+
+        auctioneer.hammer_fall()
+        bar.update(1)
+
+    total_cost = sum([b.openai_cost for b in bidder_list]) + auctioneer.openai_cost
+    bidder_reports = [bidder.profit_report() for bidder in bidder_list]
+    
+    if yield_for_demo:
+        chatbot_list = bidders_to_chatbots(bidder_list, profit_report=True)
+        yield [bidder_list] + chatbot_list + monitor_all(bidder_list) + [auctioneer.log(bidder_reports) + f'\n## Total Cost: ${total_cost}'] + [disable_gr, enable_gr] + disable_all_box(bidder_list)
+    
+    memo = {'auction_log': auctioneer.log(show_model_name=False),
+            'memo_text': bidder_reports,
+            'profit': {bidder.name: bidder.profit for bidder in bidder_list},
+            'total_cost': total_cost,
+            'learnings': {bidder.name: bidder.learnings for bidder in bidder_list},
+            'model_info': {bidder.name: bidder.model_name for bidder in bidder_list}}
+    log_bidders(log_dir, auction_hash, bidder_list, repeat_num, memo)
+    
+    auctioneer.finish_auction()
+    
+    if not yield_for_demo:
+        yield total_cost
+
+
+def log_bidders(log_dir: str, auction_hash: str, bidder_list: List[Bidder], repeat_num: int, memo: dict):
+    for bidder in bidder_list:
+        log_file = f"{log_dir}/{auction_hash}/{bidder.name.replace(' ', '')}-{repeat_num}.jsonl"
+        if not os.path.exists(log_file):
+            os.makedirs(os.path.dirname(log_file), exist_ok=True)
+        with open(log_file, 'a') as f:
+            log_data = bidder.to_monitors(as_json=True)
+            f.write(json.dumps(log_data) + '\n')
+    
+    with open(f"{log_dir}/{auction_hash}/memo-{repeat_num}.json", 'w') as f:
+        f.write(json.dumps(memo) + '\n')
+
+
+def make_auction_hash():
+    return str(int(time.time()))
+
+
+if __name__ == '__main__':
+    import argparse
+    from src.item_base import create_items
+    from src.bidder_base import create_bidders
+    from transformers import GPT2TokenizerFast
+    import cjjpy as cjj
+    
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--input_dir', '-i', type=str, default='data/exp_base/')
+    parser.add_argument('--shuffle', action='store_true')
+    parser.add_argument('--repeat', type=int, default=1)
+    parser.add_argument('--threads', '-t', type=int, help='Number of threads. Max is number of bidders. Reduce it if rate limit is low (e.g., GPT-4).', required=True)
+    parser.add_argument('--memo_file', '-m', type=str, help='The last memo.json file to be loaded for learning. Only useful when the repeated auctions are interrupted (i.e., auction hash is different).')
+    args = parser.parse_args()
+    
+    auction_hash = make_auction_hash()
+    
+    total_money_spent = 0
+    for i in tqdm(range(args.repeat), desc='Repeat'):
+        cnt = 3
+        while cnt > 0:
+            try: 
+                item_file = os.path.join(args.input_dir, f'items_demo.jsonl')
+                bidder_file = os.path.join(args.input_dir, f'bidders_demo.jsonl')
+                memo_file = args.memo_file if args.memo_file else f'{args.input_dir}/{auction_hash}/memo-{i-1}.json' # past memo for learning
+                items = create_items(item_file)
+                bidders = create_bidders(bidder_file, auction_hash=auction_hash)
+                auctioneer = Auctioneer(enable_discount=False)
+                auctioneer.init_items(items)
+                if args.shuffle:
+                    auctioneer.shuffle_items()
+                money_spent = list(run_auction(
+                    auction_hash, 
+                    auctioneer, 
+                    bidders, 
+                    thread_num=min(args.threads, len(bidders)), 
+                    yield_for_demo=False, 
+                    log_dir=args.input_dir,
+                    repeat_num=i,
+                    memo_file=memo_file,
+                ))
+                total_money_spent += sum(money_spent)
+                break
+            except Exception as e:
+                cnt -= 1
+                print(f"Error in {i}th auction: {e}\n{trace_back(e)}")
+                print(f"Retry {cnt} more times...")
+    
+    print('Total money spent: $', total_money_spent)
+    cjj.SendEmail(f'Completed: {args.input_dir} - {auction_hash}', f'Total money spent: ${total_money_spent}')

data/bidders_demo.jsonl

@@ -0,0 +1,4 @@
+{"name": "Bidder 1", "model_name": "gpt-3.5-turbo-0613", "budget": 20000, "desire": "maximize_profit", "plan_strategy": "adaptive", "temperature": 0.7, "overestimate_percent": 10, "correct_belief": true, "enable_learning": true}
+{"name": "Bidder 2", "model_name": "gpt-3.5-turbo-0613", "budget": 20000, "desire": "maximize_items", "plan_strategy": "adaptive", "temperature": 0.7, "overestimate_percent": 10, "correct_belief": true, "enable_learning": true}
+{"name": "Bidder 3", "model_name": "gpt-3.5-turbo-0613", "budget": 20000, "desire": "maximize_profit", "plan_strategy": "adaptive", "temperature": 0.7, "overestimate_percent": 10, "correct_belief": true, "enable_learning": true}
+{"name": "Bidder 4", "model_name": "gpt-3.5-turbo-0613", "budget": 20000, "desire": "maximize_items", "plan_strategy": "adaptive", "temperature": 0.7, "overestimate_percent": 10, "correct_belief": true, "enable_learning": true}

data/items_demo.jsonl

@@ -0,0 +1,26 @@
+{"name": "Widget A", "price": 1000, "desc": "A widget for all your needs", "id": 1, "true_value": 2000}
+{"name": "Gadget B", "price": 1000, "desc": "A gadget with all the latest features", "id": 2, "true_value": 2000}
+{"name": "Thingamajig C", "price": 1000, "desc": "A little thing that is sure to impress", "id": 3, "true_value": 2000}
+{"name": "Doodad D", "price": 1000, "desc": "A durable doodad that will last for years", "id": 4, "true_value": 2000}
+{"name": "Equipment E", "price": 5000, "desc": "A piece of equipment for any tough job", "id": 5, "true_value": 10000}
+{"name": "Gizmo F", "price": 1000, "desc": "A gizmo that will surprise and delight", "id": 6, "true_value": 2000}
+{"name": "Implement G", "price": 1000, "desc": "A implement for everyday tasks", "id": 7, "true_value": 2000}
+{"name": "Apparatus H", "price": 1000, "desc": "An apparatus for specialized operations", "id": 8, "true_value": 2000}
+{"name": "Contraption I", "price": 1000, "desc": "A contraption that sparks creativity", "id": 9, "true_value": 2000}
+{"name": "Mechanism J", "price": 5000, "desc": "A mechanism for repetitive tasks", "id": 10, "true_value": 10000}
+{"name": "Tool K", "price": 1000, "desc": "A tool for complex projects", "id": 11, "true_value": 2000}
+{"name": "Device L", "price": 1000, "desc": "A device that enhances performance", "id": 12, "true_value": 2000}
+{"name": "Instrument M", "price": 1000, "desc": "A instrument for precise measurements", "id": 13, "true_value": 2000}
+{"name": "Utensil N", "price": 1000, "desc": "A utensil for dining and cooking", "id": 14, "true_value": 2000}
+{"name": "Appliance O", "price": 1000, "desc": "A appliance for everyday household tasks", "id": 15, "true_value": 2000}
+{"name": "Machine P", "price": 5000, "desc": "A machine for automated tasks", "id": 16, "true_value": 10000}
+{"name": "Unit Q", "price": 1000, "desc": "A unit for individual tasks", "id": 17, "true_value": 2000}
+{"name": "Element R", "price": 5000, "desc": "A element for scientific investigations", "id": 18, "true_value": 10000}
+{"name": "Component S", "price": 1000, "desc": "A component for assembly and repair", "id": 19, "true_value": 2000}
+{"name": "Piece T", "price": 1000, "desc": "A piece for art and craft projects", "id": 20, "true_value": 2000}
+{"name": "Object U", "price": 1000, "desc": "An object for miscellaneous uses", "id": 21, "true_value": 2000}
+{"name": "Item V", "price": 1000, "desc": "An item for versatile applications", "id": 22, "true_value": 2000}
+{"name": "Product W", "price": 1000, "desc": "A product designed for efficiency", "id": 23, "true_value": 2000}
+{"name": "Accessory X", "price": 1000, "desc": "An accessory to complement any outfit", "id": 24, "true_value": 2000}
+{"name": "Module Y", "price": 1000, "desc": "A module for modular systems", "id": 25, "true_value": 2000}
+{"name": "Entity Z", "price": 1000, "desc": "An entity with unique properties", "id": 26, "true_value": 2000}

requirements.txt

@@ -0,0 +1,20 @@
+openai>=0.27.8
+langchain>=0.0.234
+anthropic>=0.3.10
+gradio
+pydantic
+coloredlogs
+ujson
+tiktoken
+tqdm
+inflect
+vertexai
+google-cloud-aiplatform>=1.28.1
+torch
+pygments
+matplotlib
+transformers
+trueskill
+seaborn
+vllm
+google-generativeai

src/auctioneer_base.py

@@ -0,0 +1,259 @@
+import re
+from typing import List, Dict
+from langchain.prompts import PromptTemplate
+from langchain.chat_models import ChatOpenAI
+from langchain.callbacks import get_openai_callback
+from pydantic import BaseModel
+from collections import defaultdict
+from langchain.schema import (
+    AIMessage,
+    HumanMessage,
+    SystemMessage
+)
+import random
+import inflect
+from .bidder_base import Bidder
+from .human_bidder import HumanBidder
+from .item_base import Item
+from .prompt_base import PARSE_BID_INSTRUCTION
+
+p = inflect.engine()
+
+
+class Auctioneer(BaseModel):
+    enable_discount: bool = False
+    items: List[Item] = []
+    cur_item: Item = None
+    highest_bidder: Bidder = None
+    highest_bid: int = -1
+    bidding_history = defaultdict(list) # history about the bidding war of one item
+    items_queue: List[Item] = []   # updates when a item is taken.
+    auction_logs = defaultdict(list)    # history about the bidding war of all items
+    openai_cost = 0
+    prev_round_max_bid: int = -1
+    min_bid: int = 0
+    fail_to_sell = False
+    min_markup_pct = 0.1
+
+    class Config:
+        arbitrary_types_allowed = True
+    
+    def init_items(self, items: List[Item]):
+        for item in items:
+            # reset discounted price
+            item.reset_price()
+        self.items = items
+        self.items_queue = items.copy()
+
+    def summarize_items_info(self):
+        desc = ''
+        for item in self.items:
+            desc += f"- {item.get_desc()}\n"
+        return desc.strip()
+    
+    def present_item(self):
+        cur_item = self.items_queue.pop(0)
+        self.cur_item = cur_item
+        return cur_item
+    
+    def shuffle_items(self):
+        random.shuffle(self.items)
+        self.items_queue = self.items.copy()
+    
+    def record_bid(self, bid_info: dict, bid_round: int):
+        '''
+        Save the bidding history for each round, log the highest bidder and highest bidding
+        '''
+        # bid_info: {'bidder': xxx, 'bid': xxx, 'raw_msg': xxx}
+        self.bidding_history[bid_round].append(bid_info)
+        for hist in self.bidding_history[bid_round]:
+            if hist['bid'] > 0:
+                if self.highest_bid < hist['bid']:
+                    self.highest_bid = hist['bid']
+                    self.highest_bidder = hist['bidder']
+                elif self.highest_bid == hist['bid']:
+                    # random if there's a tie
+                    self.highest_bidder = random.choice([self.highest_bidder, hist['bidder']])
+        self.auction_logs[f"{self.cur_item.get_desc()}"].append(
+            {'bidder': bid_info['bidder'], 
+             'bid': bid_info['bid'], 
+             'bid_round': bid_round})
+
+    def _biddings_to_string(self, bid_round: int):
+        '''
+        Return a string that summarizes the bidding history in a round
+        '''
+        # bid_hist_text = '' if bid_round == 0 else f'- {self.highest_bidder}: ${self.highest_bid}\n'
+        bid_hist_text = ''
+        for js in self.bidding_history[bid_round]:
+            if js['bid'] < 0:
+                bid_hist_text += f"- {js['bidder']} withdrew\n"
+            else:
+                bid_hist_text += f"- {js['bidder']}: ${js['bid']}\n"
+        return bid_hist_text.strip()
+    
+    def all_bidding_history_to_string(self):
+        bid_hist_text = ''
+        for bid_round in self.bidding_history:
+            bid_hist_text += f"Round {bid_round}:\n{self._biddings_to_string(bid_round)}\n\n"
+        return bid_hist_text.strip()
+
+    def ask_for_bid(self, bid_round: int):
+        '''
+        Ask for bid, return the message to be sent to bidders
+        '''
+        if self.highest_bidder is None:
+            if bid_round > 0:
+                msg = f"Seeing as we've had no takers at the initial price, we're going to lower the starting bid to ${self.cur_item.price} for {self.cur_item.name} to spark some interest! Do I have any takers?"
+            else:
+                remaining_items = [self.cur_item.name] + [item.name for item in self.items_queue]
+                msg = f"Attention, bidders! {len(remaining_items)} item(s) left, they are: {', '.join(remaining_items)}.\n\nNow, please bid on {self.cur_item}. The starting price for bidding for {self.cur_item} is ${self.cur_item.price}. Anyone interested in this item?"
+        else:
+            bidding_history = self._biddings_to_string(bid_round - 1)
+            msg = f"Thank you! This is the {p.ordinal(bid_round)} round of bidding for this item:\n{bidding_history}\n\nNow we have ${self.highest_bid} from {self.highest_bidder.name} for {self.cur_item.name}. The minimum increase over this highest bid is ${int(self.cur_item.price * self.min_markup_pct)}. Do I have any advance on ${self.highest_bid}?"
+        return msg
+    
+    def ask_for_rebid(self, fail_msg: str, bid_price: int):
+        return f"Your bid of ${bid_price} failed, because {fail_msg}: You must reconsider your bid."
+
+    def get_hammer_msg(self):
+        if self.highest_bidder is None:
+            return f"Since no one bid on {self.cur_item.name}, we'll move on to the next item."
+        else:
+            return f"Sold! {self.cur_item} to {self.highest_bidder} at ${self.highest_bid}! The true value for {self.cur_item} is ${self.cur_item.true_value}."# Thus {self.highest_bidder}'s profit by winning this item is ${self.cur_item.true_value - self.highest_bid}."
+
+    def check_hammer(self, bid_round: int):
+        # check if the item is sold
+        self.fail_to_sell = False
+        num_bid = self._num_bids_in_round(bid_round)
+
+        # highest_bidder has already been updated in record_bid().
+        # so when num_bid == 0 & highest_bidder is None, it means no one bid on this item
+        if self.highest_bidder is None:
+            if num_bid == 0:
+                # failed to sell, as there is no highest bidder
+                self.fail_to_sell = True
+                if self.enable_discount and bid_round < 3:
+                    # lower the starting price by 50%. discoutn only applies to the first 3 rounds
+                    self.cur_item.lower_price(0.5)
+                    is_sold = False
+                else:
+                    is_sold = True
+            else:
+                # won't happen
+                raise ValueError(f"highest_bidder is None but num_bid is {num_bid}")
+        else:
+            if self.prev_round_max_bid < 0 and num_bid == 1:
+                # only one bidder in the first round 
+                is_sold = True
+            else:
+                self.prev_round_max_bid = self.highest_bid
+                is_sold = self._num_bids_in_round(bid_round) == 0
+        return is_sold
+    
+    def _num_bids_in_round(self, bid_round: int):
+        # check if there is no bid in the current round
+        cnt = 0
+        for hist in self.bidding_history[bid_round]:
+            if hist['bid'] > 0:
+                cnt += 1
+        return cnt
+
+    def hammer_fall(self):
+        print(f'* Sold! {self.cur_item} (${self.cur_item.true_value}) goes to {self.highest_bidder} at ${self.highest_bid}.')
+        self.auction_logs[f"{self.cur_item.get_desc()}"].append({
+            'bidder': self.highest_bidder, 
+            'bid': f"{self.highest_bid} (${self.cur_item.true_value})",     # no need for the first $, as it will be added in the self.log()
+            'bid_round': 'Hammer price (true value)'})
+        self.cur_item = None
+        self.highest_bidder = None
+        self.highest_bid = -1
+        self.bidding_history = defaultdict(list)
+        self.prev_round_max_bid = -1
+        self.fail_to_sell = False
+
+    def end_auction(self):
+        return len(self.items_queue) == 0
+    
+    def gather_all_status(self, bidders: List[Bidder]):
+        status = {}
+        for bidder in bidders:
+            status[bidder.name] = {
+                'profit': bidder.profit, 
+                'items_won': bidder.items_won
+            }
+        return status
+
+    def parse_bid(self, text: str):
+        prompt = PARSE_BID_INSTRUCTION.format(response=text)
+        with get_openai_callback() as cb:
+            llm = ChatOpenAI(model='gpt-3.5-turbo-0613', temperature=0)
+            result = llm([HumanMessage(content=prompt)]).content
+            self.openai_cost += cb.total_cost
+        
+        bid_number = re.findall(r'\$?\d+', result.replace(',', ''))
+        # find number in the result
+        if '-1' in result:
+            return -1
+        elif len(bid_number) > 0:
+            return int(bid_number[-1].replace('$', ''))
+        else:
+            print('* Rebid:', text)
+            return None
+
+    def log(self, bidder_personal_reports: list = [], show_model_name=True):
+        ''' example
+        Apparatus H, starting at $1000.
+
+        1st bid:
+        Bidder 1 (gpt-3.5-turbo-16k-0613): $1200
+        Bidder 2 (gpt-3.5-turbo-16k-0613): $1100
+        Bidder 3 (gpt-3.5-turbo-16k-0613): Withdrawn
+        Bidder 4 (gpt-3.5-turbo-16k-0613): $1200
+        
+        2nd bid:
+        Bidder 1 (gpt-3.5-turbo-16k-0613): Withdrawn
+        Bidder 2 (gpt-3.5-turbo-16k-0613): Withdrawn
+        
+        Hammer price:
+        Bidder 4 (gpt-3.5-turbo-16k-0613): $1200
+        '''
+        markdown_output = "## Auction Log\n\n"
+        for i, (item, bids) in enumerate(self.auction_logs.items()):
+            markdown_output += f"### {i+1}. {item}\n\n"
+            cur_bid_round = -1
+            for i, bid in enumerate(bids):
+                if bid['bid_round'] != cur_bid_round:
+                    cur_bid_round = bid['bid_round']
+                    if isinstance(bid['bid_round'], int):
+                        markdown_output += f"\n#### {p.ordinal(bid['bid_round']+1)} bid:\n\n"
+                    else:
+                        markdown_output += f"\n#### {bid['bid_round']}:\n\n"
+                bid_price = f"${bid['bid']}" if bid['bid'] != -1 else 'Withdrew'
+                if isinstance(bid['bidder'], Bidder) or isinstance(bid['bidder'], HumanBidder):
+                    if show_model_name:
+                        markdown_output += f"* {bid['bidder']} ({bid['bidder'].model_name}): {bid_price}\n"
+                    else:
+                        markdown_output += f"* {bid['bidder']}: {bid_price}\n"
+                else:
+                    markdown_output += f"* None bid\n"
+            markdown_output += "\n"
+        
+        if len(bidder_personal_reports) != 0:
+            markdown_output += f"\n## Personal Report"
+            for report in bidder_personal_reports:
+                markdown_output += f"\n\n{report}"
+        return markdown_output.strip()
+    
+    def finish_auction(self):
+        self.auction_logs = defaultdict(list)
+        self.cur_item = None
+        self.highest_bidder = None
+        self.highest_bid = -1
+        self.bidding_history = defaultdict(list)
+        self.items_queue = []
+        self.items = []
+        self.prev_round_max_bid = -1
+        self.fail_to_sell = False
+        self.min_bid = 0
+        

src/bidder_base.py

@@ -0,0 +1,1031 @@
+from typing import List
+from langchain.base_language import BaseLanguageModel
+from langchain.schema import (
+    AIMessage,
+    HumanMessage,
+    SystemMessage
+)
+from langchain.chat_models import (
+    ChatAnthropic,
+    ChatOpenAI,
+    ChatVertexAI,
+    ChatGooglePalm,
+)
+import vertexai
+from langchain.input import get_colored_text
+from langchain.callbacks import get_openai_callback
+from collections import defaultdict
+from pydantic import BaseModel
+import queue
+import threading
+import os
+import random
+import time
+import ujson as json
+import matplotlib.pyplot as plt
+from .item_base import Item, item_list_equal
+from .prompt_base import (
+    AUCTION_HISTORY,
+    # INSTRUCT_OBSERVE_TEMPLATE,
+    _LEARNING_STATEMENT,
+    INSTRUCT_PLAN_TEMPLATE,
+    INSTRUCT_BID_TEMPLATE,
+    INSTRUCT_SUMMARIZE_TEMPLATE,
+    INSTRUCT_LEARNING_TEMPLATE,
+    INSTRUCT_REPLAN_TEMPLATE,
+    SYSTEM_MESSAGE,
+)
+import sys
+sys.path.append('..')
+from utils import LoadJsonL, extract_jsons_from_text, extract_numbered_list, trace_back
+
+
+# DESIRE_DESC = {
+#     'default': "Your goal is to fully utilize your budget while actively participating in the auction",
+#     'maximize_profit': "Your goal is to maximize your overall profit, and fully utilize your budget while actively participating in the auction. This involves strategic bidding to win items for less than their true value, thereby ensuring the difference between the price paid and the item's value is as large as possible",
+#     'maximize_items': "Your goal is to win as many items as possible, and fully utilize your budget while actively participating in the auction. While keeping your budget in mind, you should aim to participate broadly across different items, striving to be the highest bidder more often than not",
+# }   # remove period at the end of each description
+
+
+DESIRE_DESC = {
+    'maximize_profit': "Your primary objective is to secure the highest profit at the end of this auction, compared to all other bidders",
+    'maximize_items': "Your primary objective is to win the highest number of items at the end of this auction, compared to everyone else",
+}
+
+
+class Bidder(BaseModel):
+    name: str
+    model_name: str 
+    budget: int 
+    desire: str
+    plan_strategy: str
+    temperature: float = 0.7
+    overestimate_percent: int = 10
+    correct_belief: bool
+    enable_learning: bool = False
+    
+    llm: BaseLanguageModel = None
+    openai_cost = 0
+    llm_token_count = 0
+    
+    verbose: bool = False
+    auction_hash: str = ''
+
+    system_message: str = ''
+    original_budget: int = 0
+
+    # working memory
+    profit: int = 0
+    cur_item_id = 0
+    items: list = []
+    dialogue_history: list = []     # for gradio UI display
+    llm_prompt_history: list = []   # for tracking llm calling
+    items_won = []
+    bid_history: list = []      # history of the bidding of a single item
+    plan_instruct: str = ''     # instruction for planning
+    cur_plan: str = ''          # current plan
+    status_quo: dict = {}       # belief of budget and profit, self and others
+    withdraw: bool = False      # state of withdraw
+    learnings: str = ''         # learnings from previous biddings. If given, then use it to guide the rest of the auction.
+    max_bid_cnt: int = 4        # Rule Bidder: maximum number of bids on one item (K = 1 starting bid + K-1 increase bid)
+    rule_bid_cnt: int = 0       # Rule Bidder: count of bids on one item
+
+    # belief tracking
+    failed_bid_cnt: int = 0   # count of failed bids (overspending)
+    total_bid_cnt: int = 0    # count of total bids
+    self_belief_error_cnt: int = 0
+    total_self_belief_cnt: int = 0
+    other_belief_error_cnt: int = 0
+    total_other_belief_cnt: int = 0
+    
+    engagement_count: int = 0
+    budget_history = []
+    profit_history = []
+    budget_error_history = []
+    profit_error_history = []
+    win_bid_error_history = []
+    engagement_history = defaultdict(int)
+    all_bidders_status = {}   # track others' profit
+    changes_of_plan = []
+    
+    # not used
+    input_box: str = None
+    need_input = False
+    semaphore = 0
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def __repr__(self):
+        return self.name
+
+    def __str__(self):
+        return self.name
+    
+    @classmethod
+    def create(cls, **data):
+        instance = cls(**data)
+        instance._post_init()
+        return instance
+
+    def _post_init(self):
+        self.original_budget = self.budget
+        self.system_message = SYSTEM_MESSAGE.format(
+            name=self.name,
+            desire_desc=DESIRE_DESC[self.desire],
+        )
+        self._parse_llm()
+        self.dialogue_history += [
+            SystemMessage(content=self.system_message), 
+            AIMessage(content='')
+        ]
+        self.budget_history.append(self.budget)
+        self.profit_history.append(self.profit)
+
+    def _parse_llm(self):
+        if 'gpt-' in self.model_name:
+            self.llm = ChatOpenAI(model=self.model_name, temperature=self.temperature, max_retries=30, request_timeout=1200)
+        elif 'claude' in self.model_name:
+            self.llm = ChatAnthropic(model=self.model_name, temperature=self.temperature, default_request_timeout=1200)
+        elif 'bison' in self.model_name:
+            self.llm = ChatGooglePalm(model_name=f'models/{self.model_name}', temperature=self.temperature)
+        elif 'rule' in self.model_name or 'human' in self.model_name:
+            self.llm = None
+        else:
+            raise NotImplementedError(self.model_name)
+    
+    # def _rotate_openai_org(self):
+    #     # use two organizations to avoid rate limit
+    #     if os.environ.get('OPENAI_ORGANIZATION_1') and os.environ.get('OPENAI_ORGANIZATION_2'):
+    #         return random.choice([os.environ.get('OPENAI_ORGANIZATION_1'), os.environ.get('OPENAI_ORGANIZATION_2')])
+    #     else:
+    #         return None
+    
+    def _run_llm_standalone(self, messages: list):
+        
+        with get_openai_callback() as cb:
+            for i in range(6):
+                try:
+                    input_token_num = self.llm.get_num_tokens_from_messages(messages)
+                    if 'claude' in self.model_name:     # anthropic's claude
+                        result = self.llm(messages, max_tokens_to_sample=2048)
+                    elif 'bison' in self.model_name:    # google's palm-2
+                        max_tokens = min(max(3900 - input_token_num, 192), 2048)
+                        if isinstance(self.llm, ChatVertexAI):
+                            result = self.llm(messages, max_output_tokens=max_tokens)
+                        else:
+                            result = self.llm(messages)
+                    elif 'gpt' in self.model_name:      # openai
+                        if 'gpt-3.5-turbo' in self.model_name and '16k' not in self.model_name:
+                            max_tokens = max(3900 - input_token_num, 192)
+                        else:
+                            # gpt-4
+                            # self.llm.openai_organization = self._rotate_openai_org()
+                            max_tokens = max(8000 - input_token_num, 192)
+                        result = self.llm(messages, max_tokens=max_tokens)
+                    elif 'llama' in self.model_name.lower():
+                        raise NotImplementedError
+                    else:
+                        raise NotImplementedError
+                    break
+                except:
+                    print(f'Retrying for {self.model_name} ({i+1}/6), wait for {2**(i+1)} sec...')
+                    time.sleep(2**(i+1))
+            self.openai_cost += cb.total_cost
+            self.llm_token_count = self.llm.get_num_tokens_from_messages(messages)
+        return result.content
+
+    def _get_estimated_value(self, item):
+        value = item.true_value * (1 + self.overestimate_percent / 100)
+        return int(value)
+    
+    def _get_cur_item(self, key=None):
+        if self.cur_item_id < len(self.items):
+            if key is not None:
+                return self.items[self.cur_item_id].__dict__[key]
+            else:
+                return self.items[self.cur_item_id]
+        else:
+            return 'no item left'
+    
+    def _get_next_item(self, key=None):
+        if self.cur_item_id + 1 < len(self.items):
+            if key is not None:
+                return self.items[self.cur_item_id + 1].__dict__[key]
+            else:
+                return self.items[self.cur_item_id + 1]
+        else:
+            return 'no item left'
+    
+    def _get_remaining_items(self, as_str=False):
+        remain_items = self.items[self.cur_item_id + 1:]
+        if as_str:
+            return ', '.join([item.name for item in remain_items])
+        else:
+            return remain_items
+    
+    def _get_items_value_str(self, items: List[Item]):
+        if not isinstance(items, list):
+            items = [items]
+        items_info = ''
+        for i, item in enumerate(items):
+            estimated_value = self._get_estimated_value(item)
+            _info = f"{i+1}. {item}, starting price is ${item.price}. Your estimated value for this item is ${estimated_value}.\n"
+            items_info += _info
+        return items_info.strip()
+    
+    # ********** Main Instructions and Functions ********** #
+    
+    def learn_from_prev_auction(self, past_learnings, past_auction_log):
+        if not self.enable_learning or 'rule' in self.model_name or 'human' in self.model_name:
+            return ''
+        
+        instruct_learn = INSTRUCT_LEARNING_TEMPLATE.format(
+            past_auction_log=past_auction_log,
+            past_learnings=past_learnings)
+
+        result = self._run_llm_standalone([HumanMessage(content=instruct_learn)])
+        self.dialogue_history += [
+            HumanMessage(content=instruct_learn),
+            AIMessage(content=result),
+        ]
+        self.llm_prompt_history.append({
+            'messages': [{x.type: x.content} for x in [HumanMessage(content=instruct_learn)]],
+            'result': result,
+            'tag': 'learn_0'
+        })
+        
+        self.learnings = '\n'.join(extract_numbered_list(result))
+        if self.learnings != '':
+            self.system_message += f"\n\nHere are your key learning points and practical tips from a previous auction. You can use them to guide this auction:\n```\n{self.learnings}\n```"
+        
+        if self.verbose:
+            print(f"Learn from previous auction: {self.name} ({self.model_name}).")
+        return result
+
+    def _choose_items(self, budget, items: List[Item]):
+        '''
+        Choose items within budget for rule bidders.
+        Cheap ones first if maximize_items, expensive ones first if maximize_profit.
+        '''
+        sorted_items = sorted(items, key=lambda x: self._get_estimated_value(x), 
+                              reverse=self.desire == 'maximize_profit')
+        
+        chosen_items = []
+        i = 0
+        while budget >= 0 and i < len(sorted_items):
+            item = sorted_items[i]
+            if item.price <= budget:
+                chosen_items.append(item)
+                budget -= item.price
+            i += 1
+        
+        return chosen_items
+    
+    def get_plan_instruct(self, items: List[Item]):
+        self.items = items
+        plan_instruct = INSTRUCT_PLAN_TEMPLATE.format(
+            bidder_name=self.name,       
+            budget=self.budget, 
+            item_num=len(items), 
+            items_info=self._get_items_value_str(items), 
+            desire_desc=DESIRE_DESC[self.desire],
+            learning_statement='' if not self.enable_learning else _LEARNING_STATEMENT
+        )
+        return plan_instruct
+    
+    def init_plan(self, plan_instruct: str):
+        '''
+        Plan for bidding with auctioneer's instruction and items information for customize estimated value.
+        plan = plan(system_message, instruct_plan)
+        '''
+        if 'rule' in self.model_name: 
+            # self.cur_plan = ', '.join([x.name for x in self._choose_items(self.budget, self.items)])
+            # self.dialogue_history += [
+            #     HumanMessage(content=plan_instruct),
+            #     AIMessage(content=self.cur_plan),
+            # ]
+            # return self.cur_plan
+            return ''
+
+        self.status_quo = {
+            'remaining_budget': self.budget,
+            'total_profits': {bidder: 0 for bidder in self.all_bidders_status.keys()},
+            'winning_bids': {bidder: {} for bidder in self.all_bidders_status.keys()},
+        }
+
+        if self.plan_strategy == 'none':
+            self.plan_instruct = ''
+            self.cur_plan = ''
+            return None
+
+        system_msg = SystemMessage(content=self.system_message)
+        plan_msg = HumanMessage(content=plan_instruct)
+        messages = [system_msg, plan_msg]
+        result = self._run_llm_standalone(messages)
+        
+        if self.verbose:
+            print(get_colored_text(plan_msg.content, 'red'))
+            print(get_colored_text(result, 'green'))
+        
+        self.dialogue_history += [
+            plan_msg,
+            AIMessage(content=result),
+        ]
+        self.llm_prompt_history.append({
+            'messages': [{x.type: x.content} for x in messages],
+            'result': result,
+            'tag': 'plan_0'
+        })
+        self.cur_plan = result
+        self.plan_instruct = plan_instruct
+        
+        self.changes_of_plan.append([
+            f"{self.cur_item_id} (Initial)", 
+            False, 
+            json.dumps(extract_jsons_from_text(result)[-1]),
+        ])
+        
+        if self.verbose:
+            print(f"Plan: {self.name} ({self.model_name}) for {self._get_cur_item()}.")
+        return result
+    
+    def get_rebid_instruct(self, auctioneer_msg: str):
+        self.dialogue_history += [
+            HumanMessage(content=auctioneer_msg),
+            AIMessage(content='')
+        ]
+        return auctioneer_msg
+
+    def get_bid_instruct(self, auctioneer_msg: str, bid_round: int):
+        auctioneer_msg = auctioneer_msg.replace(self.name, f'You ({self.name})')
+        
+        bid_instruct = INSTRUCT_BID_TEMPLATE.format(
+            auctioneer_msg=auctioneer_msg, 
+            bidder_name=self.name,
+            cur_item=self._get_cur_item(),
+            estimated_value=self._get_estimated_value(self._get_cur_item()),
+            desire_desc=DESIRE_DESC[self.desire],
+            learning_statement='' if not self.enable_learning else _LEARNING_STATEMENT
+        )
+        if bid_round == 0:
+            if self.plan_strategy in ['static', 'none']:
+                # if static planner, then no replanning is needed. status quo is updated in replanning. thus need to add status quo in bid instruct.
+                bid_instruct = f"""The status quo of this auction so far is:\n"{json.dumps(self.status_quo, indent=4)}"\n\n{bid_instruct}\n---\n"""
+        else:
+            bid_instruct = f'Now, the auctioneer says: "{auctioneer_msg}"'
+        
+        self.dialogue_history += [
+            HumanMessage(content=bid_instruct),
+            AIMessage(content='')
+        ]
+        return bid_instruct
+    
+    def bid_rule(self, cur_bid: int, min_markup_pct: float = 0.1):
+        '''
+        :param cur_bid: current highest bid
+        :param min_markup_pct: minimum percentage for bid increase
+        :param max_bid_cnt: maximum number of bids on one item (K = 1 starting bid + K-1 increase bid)
+        '''
+        # dialogue history already got bid_instruction.
+        cur_item = self._get_cur_item()
+        
+        if cur_bid <= 0:
+            next_bid = cur_item.price
+        else:
+            next_bid = cur_bid + min_markup_pct * cur_item.price
+        
+        if self.budget - next_bid >= 0 and self.rule_bid_cnt < self.max_bid_cnt:
+            msg = int(next_bid)
+            self.rule_bid_cnt += 1
+        else:
+            msg = -1
+        
+        content = f'The current highest bid for {cur_item.name} is ${cur_bid}. '
+        content += "I'm out!" if msg < 0 else f"I bid ${msg}! (Rule generated)"
+        self.dialogue_history += [
+            HumanMessage(content=''),
+            AIMessage(content=content)
+        ]
+        
+        return msg
+    
+    def bid(self, bid_instruct):
+        '''
+        Bid for an item with auctioneer's instruction and bidding history.
+        bid_history = bid(system_message, instruct_plan, plan, bid_history)
+        '''
+        if self.model_name == 'rule':
+            return ''
+        
+        bid_msg = HumanMessage(content=bid_instruct)
+        
+        if self.plan_strategy == 'none':
+            messages = [SystemMessage(content=self.system_message)]
+        else:
+            messages = [SystemMessage(content=self.system_message),
+                        HumanMessage(content=self.plan_instruct),
+                        AIMessage(content=self.cur_plan)]
+        
+        self.bid_history += [bid_msg]
+        messages += self.bid_history
+        
+        result = self._run_llm_standalone(messages)
+        
+        self.bid_history += [AIMessage(content=result)]
+
+        self.dialogue_history += [
+            HumanMessage(content=''),
+            AIMessage(content=result)
+        ]
+        
+        self.llm_prompt_history.append({
+            'messages': [{x.type: x.content} for x in messages],
+            'result': result,
+            'tag': f'bid_{self.cur_item_id}'
+        })
+        
+        if self.verbose:
+            print(get_colored_text(bid_instruct, 'yellow'))
+            print(get_colored_text(result, 'green'))
+        
+            print(f"Bid: {self.name} ({self.model_name}) for {self._get_cur_item()}.")
+        self.total_bid_cnt += 1
+        
+        return result
+
+    def get_summarize_instruct(self, bidding_history: str, hammer_msg: str, win_lose_msg: str):
+        instruct = INSTRUCT_SUMMARIZE_TEMPLATE.format(
+            cur_item=self._get_cur_item(), 
+            bidding_history=bidding_history, 
+            hammer_msg=hammer_msg.strip(), 
+            win_lose_msg=win_lose_msg.strip(), 
+            bidder_name=self.name,
+            prev_status=self._status_json_to_text(self.status_quo),
+        )
+        return instruct
+
+    def summarize(self, instruct_summarize: str):
+        '''
+        Update belief/status quo
+        status_quo = summarize(system_message, bid_history, prev_status + instruct_summarize)
+        '''
+        self.budget_history.append(self.budget)
+        self.profit_history.append(self.profit)
+        
+        if self.model_name == 'rule': 
+            self.rule_bid_cnt = 0   # reset bid count for rule bidder
+            return ''
+        
+        messages = [SystemMessage(content=self.system_message)]
+        # messages += self.bid_history
+        summ_msg = HumanMessage(content=instruct_summarize)
+        messages.append(summ_msg)
+
+        status_quo_text = self._run_llm_standalone(messages)
+        
+        self.dialogue_history += [summ_msg, AIMessage(content=status_quo_text)]
+        self.bid_history += [summ_msg, AIMessage(content=status_quo_text)]
+        
+        self.llm_prompt_history.append({
+            'messages': [{x.type: x.content} for x in messages],
+            'result': status_quo_text,
+            'tag': f'summarize_{self.cur_item_id}'
+        })
+
+        cnt = 0
+        while cnt <= 3:
+            sanity_msg = self._sanity_check_status_json(extract_jsons_from_text(status_quo_text)[-1])
+            if sanity_msg == '':
+                # pass sanity check then track beliefs
+                consistency_msg = self._belief_tracking(status_quo_text)
+            else:
+                sanity_msg = f'- {sanity_msg}'
+                consistency_msg = ''
+                
+            if sanity_msg != '' or (consistency_msg != '' and self.correct_belief):
+                err_msg = f"As {self.name}, here are some error(s) of your summary of the status JSON:\n{sanity_msg.strip()}\n{consistency_msg.strip()}\n\nPlease revise the status JSON based on the errors. Don't apologize. Just give me the revised status JSON.".strip()
+                
+                # print(f"{self.name}: revising status quo for the {cnt} time:")
+                # print(get_colored_text(err_msg, 'green'))
+                # print(get_colored_text(status_quo_text, 'red'))
+                
+                messages += [AIMessage(content=status_quo_text), 
+                             HumanMessage(content=err_msg)]
+                status_quo_text = self._run_llm_standalone(messages)
+                self.dialogue_history += [
+                    HumanMessage(content=err_msg),
+                    AIMessage(content=status_quo_text),
+                ]
+                cnt += 1
+            else:
+                break
+        
+        self.status_quo = extract_jsons_from_text(status_quo_text)[-1]
+
+        if self.verbose:
+            print(get_colored_text(instruct_summarize, 'blue'))
+            print(get_colored_text(status_quo_text, 'green'))
+        
+            print(f"Summarize: {self.name} ({self.model_name}) for {self._get_cur_item()}.")
+        
+        return status_quo_text
+    
+    def get_replan_instruct(self):
+        instruct = INSTRUCT_REPLAN_TEMPLATE.format(
+            status_quo=self._status_json_to_text(self.status_quo),
+            remaining_items_info=self._get_items_value_str(self._get_remaining_items()),
+            bidder_name=self.name,
+            desire_desc=DESIRE_DESC[self.desire],
+            learning_statement='' if not self.enable_learning else _LEARNING_STATEMENT
+        )
+        return instruct
+
+    def replan(self, instruct_replan: str):
+        '''
+        plan = replan(system_message, instruct_plan, prev_plan, status_quo + (learning) + instruct_replan)
+        '''
+        if self.model_name == 'rule': 
+            self.withdraw = False
+            self.cur_item_id += 1
+            return ''
+        
+        if self.plan_strategy in ['none', 'static']:
+            self.bid_history = []  # clear bid history
+            self.cur_item_id += 1
+            self.withdraw = False
+            return 'Skip replanning for bidders with static or no plan.'
+        
+        replan_msg = HumanMessage(content=instruct_replan)
+        
+        messages = [SystemMessage(content=self.system_message),
+                    HumanMessage(content=self.plan_instruct),
+                    AIMessage(content=self.cur_plan)]
+        messages.append(replan_msg)
+
+        result = self._run_llm_standalone(messages)
+        
+        new_plan_dict = extract_jsons_from_text(result)[-1]
+        cnt = 0
+        while len(new_plan_dict) == 0 and cnt < 2:
+            err_msg = 'Your response does not contain a JSON-format priority list for items. Please revise your plan.'
+            messages += [
+                AIMessage(content=result),
+                HumanMessage(content=err_msg),
+            ]
+            result = self._run_llm_standalone(messages)
+            new_plan_dict = extract_jsons_from_text(result)[-1]
+            
+            self.dialogue_history += [
+                HumanMessage(content=err_msg),
+                AIMessage(content=result),
+            ]
+            cnt += 1
+        
+        old_plan_dict = extract_jsons_from_text(self.cur_plan)[-1]
+        self.changes_of_plan.append([
+            f"{self.cur_item_id + 1} ({self._get_cur_item('name')})", 
+            self._change_of_plan(old_plan_dict, new_plan_dict),
+            json.dumps(new_plan_dict)
+        ])
+    
+        self.plan_instruct = instruct_replan
+        self.cur_plan = result
+        self.withdraw = False
+        self.bid_history = []  # clear bid history
+        self.cur_item_id += 1
+
+        self.dialogue_history += [
+            replan_msg,
+            AIMessage(content=result),
+        ]
+        self.llm_prompt_history.append({
+            'messages': [{x.type: x.content} for x in messages],
+            'result': result,
+            'tag': f'plan_{self.cur_item_id}'
+        })
+        
+        if self.verbose:
+            print(get_colored_text(instruct_replan, 'blue'))
+            print(get_colored_text(result, 'green'))
+
+            print(f"Replan: {self.name} ({self.model_name}).")
+        return result
+    
+    def _change_of_plan(self, old_plan: dict, new_plan: dict):
+        for k in new_plan:
+            if new_plan[k] != old_plan.get(k, None):
+                return True
+        return False
+        
+    # *********** Belief Tracking and Sanity Check *********** #
+    
+    def bid_sanity_check(self, bid_price, prev_round_max_bid, min_markup_pct):
+        # can't bid more than budget or less than previous highest bid
+        if bid_price < 0:
+            msg = None
+        else:
+            min_bid_increase = int(min_markup_pct * self._get_cur_item('price'))
+            if bid_price > self.budget:
+                msg = f"you don't have insufficient budget (${self.budget} left)"
+            elif bid_price < self._get_cur_item('price'):
+                msg = f"your bid is lower than the starting bid (${self._get_cur_item('price')})"
+            elif bid_price < prev_round_max_bid + min_bid_increase:
+                msg = f"you must advance previous highest bid (${prev_round_max_bid}) by at least ${min_bid_increase} ({int(100 * min_markup_pct)}%)."
+            else:
+                msg = None
+        return msg
+
+    def rebid_for_failure(self, fail_instruct: str):
+        result = self.bid(fail_instruct)
+        self.failed_bid_cnt += 1
+        return result
+    
+    def _sanity_check_status_json(self, data: dict):
+        if data == {}:
+            return "Error: No parsible JSON in your response. Possibly due to missing a closing curly bracket '}', or unpasible values (e.g., 'profit': 1000 + 400, instead of 'profit': 1400)."
+
+        # Check if all expected top-level keys are present
+        expected_keys = ["remaining_budget", "total_profits", "winning_bids"]
+        for key in expected_keys:
+            if key not in data:
+                return f"Error: Missing '{key}' field in the status JSON."
+
+        # Check if "remaining_budget" is a number
+        if not isinstance(data["remaining_budget"], (int, float)):
+            return "Error: 'remaining_budget' should be a number, and only about your remaining budget."
+
+        # Check if "total_profits" is a dictionary with numbers as values
+        if not isinstance(data["total_profits"], dict):
+            return "Error: 'total_profits' should be a dictionary of every bidder."
+        for bidder, profit in data["total_profits"].items():
+            if not isinstance(profit, (int, float)):
+                return f"Error: Profit for {bidder} should be a number."
+
+        # Check if "winning_bids" is a dictionary and that each bidder's entry is a dictionary with numbers
+        if not isinstance(data["winning_bids"], dict):
+            return "Error: 'winning_bids' should be a dictionary."
+        for bidder, bids in data["winning_bids"].items():
+            if not isinstance(bids, dict):
+                return f"Error: Bids for {bidder} should be a dictionary."
+            for item, amount in bids.items():
+                if not isinstance(amount, (int, float)):
+                    return f"Error: Amount for {item} under {bidder} should be a number."
+
+        # If everything is fine
+        return ""
+    
+    def _status_json_to_text(self, data: dict):
+        if 'rule' in self.model_name: return ''
+        
+        # Extract and format remaining budget
+        structured_text = f"* Remaining Budget: ${data.get('remaining_budget', 'unknown')}\n\n"
+        
+        # Extract and format total profits for each bidder
+        structured_text += "* Total Profits:\n"
+        if data.get('total_profits'):
+            for bidder, profit in data['total_profits'].items():
+                structured_text += f"  * {bidder}: ${profit}\n"
+        
+        # Extract and list the winning bids for each item by each bidder
+        structured_text += "\n* Winning Bids:\n"
+        if data.get('winning_bids'):
+            for bidder, bids in data['winning_bids'].items():
+                structured_text += f"  * {bidder}:\n"
+                if bids:
+                    for item, amount in bids.items():
+                        structured_text += f"    * {item}: ${amount}\n"
+                else:
+                    structured_text += f"    * No winning bids\n"
+        
+        return structured_text.strip()
+
+    def _belief_tracking(self, status_text: str):
+        '''
+        Parse status quo and check if the belief is correct.
+        '''
+        belief_json = extract_jsons_from_text(status_text)[-1]
+        # {"remaining_budget": 8000, "total_profits": {"Bidder 1": 1300, "Bidder 2": 1800, "Bidder 3": 0}, "winning_bids": {"Bidder 1": {"Item 2": 1200, "Item 3": 1000}, "Bidder 2": {"Item 1": 2000}, "Bidder 3": {}}}
+        budget_belief = belief_json['remaining_budget']
+        profits_belief = belief_json['total_profits']
+        winning_bids = belief_json['winning_bids']
+
+        msg = ''
+        # track belief of budget
+        self.total_self_belief_cnt += 1
+        if budget_belief != self.budget:
+            msg += f'- Your belief of budget is wrong: you have ${self.budget} left, but you think you have ${budget_belief} left.\n'
+            self.self_belief_error_cnt += 1
+            self.budget_error_history.append([
+                self._get_cur_item('name'),
+                budget_belief,
+                self.budget,
+            ])
+        
+        # track belief of profits
+        for bidder_name, profit in profits_belief.items():
+            if self.all_bidders_status.get(bidder_name) is None:
+                # due to a potentially unreasonable parsing
+                continue
+            
+            if self.name in bidder_name: 
+                bidder_name = self.name
+                self.total_self_belief_cnt += 1
+            else:
+                self.total_other_belief_cnt += 1
+            
+            real_profit = self.all_bidders_status[bidder_name]['profit']
+            
+            if profit != real_profit:
+                if self.name == bidder_name:
+                    self.self_belief_error_cnt += 1
+                else:
+                    self.other_belief_error_cnt += 1
+
+                msg += f'- Your belief of total profit of {bidder_name} is wrong: {bidder_name} has earned ${real_profit} so far, but you think {bidder_name} has earned ${profit}.\n'
+
+                # add to history
+                self.profit_error_history.append([
+                    f"{bidder_name} ({self._get_cur_item('name')})",
+                    profit,
+                    real_profit
+                ])
+
+        # track belief of winning bids
+        for bidder_name, items_won_dict in winning_bids.items():
+            if self.all_bidders_status.get(bidder_name) is None:
+                # due to a potentially unreasonable parsing
+                continue
+
+            real_items_won = self.all_bidders_status[bidder_name]['items_won']
+            # items_won = [(item, bid_price), ...)]
+            
+            items_won_list = list(items_won_dict.keys())
+            real_items_won_list = [str(x) for x, _ in real_items_won]
+            
+            if self.name in bidder_name:
+                self.total_self_belief_cnt += 1
+            else:
+                self.total_other_belief_cnt += 1
+            
+            if not item_list_equal(items_won_list, real_items_won_list):
+                if bidder_name == self.name:
+                    self.self_belief_error_cnt += 1
+                    _bidder_name = f'you'
+                else:
+                    self.other_belief_error_cnt += 1
+                    _bidder_name = bidder_name
+                
+                msg += f"- Your belief of winning items of {bidder_name} is wrong: {bidder_name} won {real_items_won}, but you think {bidder_name} won {items_won_dict}.\n"
+
+                self.win_bid_error_history.append([
+                    f"{_bidder_name} ({self._get_cur_item('name')})",
+                    ', '.join(items_won_list),
+                    ', '.join(real_items_won_list)
+                ])
+        
+        return msg
+    
+    def win_bid(self, item: Item, bid: int):
+        self.budget -= bid
+        self.profit += item.true_value - bid
+        self.items_won += [[item, bid]]
+        msg = f"Congratuations! You won {item} at ${bid}."# Now you have ${self.budget} left. Your total profit so far is ${self.profit}."
+        return msg
+    
+    def lose_bid(self, item: Item):
+        return f"You lost {item}."# Now, you have ${self.budget} left. Your total profit so far is ${self.profit}."
+    
+    # set the profit information of other bidders
+    def set_all_bidders_status(self, all_bidders_status: dict):
+        self.all_bidders_status = all_bidders_status.copy()
+
+    def set_withdraw(self, bid: int):
+        if bid < 0:     # withdraw
+            self.withdraw = True
+        elif bid == 0:  # enable discount and bid again
+            self.withdraw = False
+        else:           # normal bid
+            self.withdraw = False
+            self.engagement_count += 1
+            self.engagement_history[self._get_cur_item('name')] += 1
+    
+    # ****************** Logging ****************** #
+    
+    # def _parse_hedging(self, plan: str):   # deprecated
+    #     prompt = PARSE_HEDGE_INSTRUCTION.format(
+    #         item_name=self._get_cur_item(), 
+    #         plan=plan)
+        
+    #     with get_openai_callback() as cb:
+    #         llm = ChatOpenAI(model='gpt-3.5-turbo-0613', temperature=0)
+    #         result = llm([HumanMessage(content=prompt)]).content
+    #         self.openai_cost += cb.total_cost
+    #         # parse a number, which could be a digit
+    #         hedge_percent = re.findall(r'\d+\.?\d*%', result)
+    #         if len(hedge_percent) > 0:
+    #             hedge_percent = hedge_percent[0].replace('%', '')
+    #         else:
+    #             hedge_percent = 0
+    #     return float(hedge_percent)
+    
+    def profit_report(self):
+        '''
+        Personal profit report at the end of an auction.
+        '''
+        msg = f"* {self.name}, starting with ${self.original_budget}, has won {len(self.items_won)} items in this auction, with a total profit of ${self.profit}.:\n"
+        profit = 0
+        for item, bid in self.items_won:
+            profit += item.true_value - bid
+            msg += f"  * Won {item} at ${bid} over ${item.price}, with a true value of ${item.true_value}.\n"
+        return msg.strip()
+    
+    def to_monitors(self, as_json=False):
+        # budget, profit, items_won, tokens
+        if len(self.items_won) == 0 and not as_json: 
+            items_won = [['', 0, 0]]
+        else:
+            items_won = []
+            for item, bid in self.items_won:
+                items_won.append([str(item), bid, item.true_value])
+        
+        profit_error_history = self.profit_error_history if self.profit_error_history != [] or as_json else [['', '', '']]
+        win_bid_error_history = self.win_bid_error_history if self.win_bid_error_history != [] or as_json else [['', '', '']]
+        budget_error_history = self.budget_error_history if self.budget_error_history != [] or as_json else [['', '']]
+        changes_of_plan = self.changes_of_plan if self.changes_of_plan != [] or as_json else [['', '', '']]
+        
+        if as_json:
+            return {
+                'auction_hash': self.auction_hash,
+                'bidder_name': self.name,
+                'model_name': self.model_name,
+                'desire': self.desire,
+                'plan_strategy': self.plan_strategy,
+                'overestimate_percent': self.overestimate_percent,
+                'temperature': self.temperature,
+                'correct_belief': self.correct_belief,
+                'enable_learning': self.enable_learning,
+                'budget': self.original_budget,
+                'money_left': self.budget,
+                'profit': self.profit,
+                'items_won': items_won,
+                'tokens_used': self.llm_token_count,
+                'openai_cost': round(self.openai_cost, 2),
+                'failed_bid_cnt': self.failed_bid_cnt,
+                'self_belief_error_cnt': self.self_belief_error_cnt,
+                'other_belief_error_cnt': self.other_belief_error_cnt,
+                'failed_bid_rate': round(self.failed_bid_cnt / (self.total_bid_cnt+1e-8), 2),
+                'self_error_rate': round(self.self_belief_error_cnt / (self.total_self_belief_cnt+1e-8), 2),
+                'other_error_rate': round(self.other_belief_error_cnt / (self.total_other_belief_cnt+1e-8), 2),
+                'engagement_count': self.engagement_count,
+                'engagement_history': self.engagement_history,
+                'changes_of_plan': changes_of_plan,
+                'budget_error_history': budget_error_history,
+                'profit_error_history': profit_error_history,
+                'win_bid_error_history': win_bid_error_history,
+                'history': self.llm_prompt_history
+            }
+        else:
+            return [
+                self.budget, 
+                self.profit, 
+                items_won, 
+                self.llm_token_count, 
+                round(self.openai_cost, 2), 
+                round(self.failed_bid_cnt / (self.total_bid_cnt+1e-8), 2), 
+                round(self.self_belief_error_cnt / (self.total_self_belief_cnt+1e-8), 2), 
+                round(self.other_belief_error_cnt / (self.total_other_belief_cnt+1e-8), 2), 
+                self.engagement_count,
+                draw_plot(f"{self.name} ({self.model_name})", self.budget_history, self.profit_history), 
+                changes_of_plan,
+                budget_error_history,
+                profit_error_history, 
+                win_bid_error_history
+            ]
+
+    def dialogue_to_chatbot(self):
+        # chatbot: [[Human, AI], [], ...]
+        # only dialogue will be sent to LLMs. chatbot is just for display.
+        assert len(self.dialogue_history) % 2 == 0
+        chatbot = []
+        for i in range(0, len(self.dialogue_history), 2):
+            # if exceeds the length of dialogue, append the last message
+            human_msg = self.dialogue_history[i].content
+            ai_msg = self.dialogue_history[i+1].content
+            if ai_msg == '': ai_msg = None
+            if human_msg == '': human_msg = None
+            chatbot.append([human_msg, ai_msg])
+        return chatbot
+
+
+def draw_plot(title, hedge_list, profit_list):
+    x1 = [str(i) for i in range(len(hedge_list))]
+    x2 = [str(i) for i in range(len(profit_list))]
+    y1 = hedge_list
+    y2 = profit_list
+
+    fig, ax1 = plt.subplots()
+    
+    color = 'tab:red'
+    ax1.set_xlabel('Bidding Round')
+    ax1.set_ylabel('Budget Left ($)', color=color)
+    ax1.plot(x1, y1, color=color, marker='o')
+    ax1.tick_params(axis='y', labelcolor=color)
+    
+    for i, j in zip(x1, y1):
+        ax1.text(i, j, str(j), color=color)
+
+    ax2 = ax1.twinx()
+    color = 'tab:blue'
+    ax2.set_ylabel('Total Profit ($)', color=color)
+    ax2.plot(x2, y2, color=color, marker='^')
+    ax2.tick_params(axis='y', labelcolor=color)
+
+    for i, j in zip(x2, y2):
+        ax2.text(i, j, str(j), color=color)
+    
+    lines1, labels1 = ax1.get_legend_handles_labels()
+    lines2, labels2 = ax2.get_legend_handles_labels()
+    ax2.legend(lines1 + lines2, labels1 + labels2, loc=0)
+
+    # fig.tight_layout()
+    plt.title(title)
+
+    return fig
+
+
+def bidding_multithread(bidder_list: List[Bidder],  
+                        instruction_list, 
+                        func_type,
+                        thread_num=5,
+                        retry=1):
+    '''
+    auctioneer_msg: either a uniform message (str) or customed (list)
+    '''
+    assert func_type in ['plan', 'bid', 'summarize', 'replan']
+    
+    result_queue = queue.Queue()
+    threads = []
+    semaphore = threading.Semaphore(thread_num)
+
+    def run_once(i: int, bidder: Bidder, auctioneer_msg: str):
+        try:
+            semaphore.acquire()
+            if func_type == 'bid':
+                
+                result = bidder.bid(auctioneer_msg)
+            elif func_type == 'summarize':
+                result = bidder.summarize(auctioneer_msg)
+            elif func_type == 'plan':
+                result = bidder.init_plan(auctioneer_msg)
+            elif func_type == 'replan':
+                result = bidder.replan(auctioneer_msg)
+            else:
+                raise NotImplementedError(f'func_type {func_type} not implemented')
+            result_queue.put((True, i, result))
+        # except Exception as e:
+        #     result_queue.put((False, i, str(trace_back(e))))
+        finally:
+            semaphore.release()
+
+    if isinstance(instruction_list, str):
+        instruction_list = [instruction_list] * len(bidder_list)
+    
+    for i, (bidder, msg) in enumerate(zip(bidder_list, instruction_list)):
+        thread = threading.Thread(target=run_once, args=(i, bidder, msg))
+        thread.start()
+        threads.append(thread)
+    
+    for thread in threads:
+        thread.join(timeout=600)
+    
+    results = [result_queue.get() for _ in range(len(bidder_list))]
+    
+    errors = []
+    for success, id, result in results:
+        if not success:
+            errors.append((id, result))
+    
+    if errors:
+        raise Exception(f"Error(s) in {func_type}:\n" + '\n'.join([f'{i}: {e}' for i, e in errors]))
+    
+    valid_results = [x[1:] for x in results if x[0]]
+    valid_results.sort()
+    
+    return [x for _, x in valid_results]
+    
+
+def bidders_to_chatbots(bidder_list: List[Bidder], profit_report=False):
+    if profit_report:   # usually at the end of an auction
+        return [x.dialogue_to_chatbot() + [[x.profit_report(), None]] for x in bidder_list]
+    else:
+        return [x.dialogue_to_chatbot() for x in bidder_list]
+
+
+def create_bidders(bidder_info_jsl, auction_hash):
+    bidder_info_jsl = LoadJsonL(bidder_info_jsl)
+    bidder_list = []
+    for info in bidder_info_jsl:
+        info['auction_hash'] = auction_hash
+        bidder_list.append(Bidder.create(**info))
+    return bidder_list

src/human_bidder.py

@@ -0,0 +1,137 @@
+from typing import List
+from langchain.schema import (
+    AIMessage,
+    HumanMessage,
+    SystemMessage
+)
+from .bidder_base import Bidder, draw_plot
+from .item_base import Item
+from langchain.input import get_colored_text
+import time
+
+
+class HumanBidder(Bidder):
+    name: str
+    human_name: str = "Adam"
+    budget: int
+    auction_hash: str
+    
+    cur_item_id = 0
+    items: list = []
+    withdraw: bool = False
+    
+    engagement_count: int = 0
+    original_budget: int = 0
+    profit: int = 0
+    items_won = []
+    
+    all_bidders_status = {}         # track others' profit
+    
+    # essential for demo
+    need_input: bool = False
+    semaphore: int = 0              # if needs input, then semaphore is set as 1, else waits.
+    input_box: str = None           # global variable for accepting user input
+    
+    # not used
+    model_name: str = 'human'
+    openai_cost = 0
+    desire = ''
+    plan_strategy = ''
+    correct_belief = True
+    
+    class Config:
+        arbitrary_types_allowed = True
+    
+    def get_plan_instruct(self, items: List[Item]):
+        self.items = items
+        plan_instruct = "As {bidder_name}, you have a total budget of ${budget}. This auction has a total of {item_num} items to be sequentially presented, they are:\n{items_info}".format(
+            bidder_name=self.name,       
+            budget=self.budget, 
+            item_num=len(items), 
+            items_info=self._get_items_value_str(items)
+        )
+        return plan_instruct
+    
+    def init_plan(self, plan_instruct: str):
+        # Human = auctioneer, AI = bidder
+        self.dialogue_history += [
+            HumanMessage(content=plan_instruct),
+            AIMessage(content='Got it!')
+        ]
+        return ''
+    
+    def get_bid_instruct(self, auctioneer_msg, bid_round):
+        self.dialogue_history += [
+            HumanMessage(content=auctioneer_msg), 
+            AIMessage(content='')
+        ]
+        return auctioneer_msg
+    
+    def bid(self, bid_instruct):
+        # wait for the cue to handle user input
+        while self.semaphore <= 0:
+            time.sleep(1)
+        
+        self.dialogue_history += [
+            HumanMessage(content=''),
+            AIMessage(content=self.input_box)
+        ]
+        self.semaphore -= 1
+        self.need_input = False
+        return self.input_box
+    
+    def get_summarize_instruct(self, bidding_history: str, hammer_msg: str, win_lose_msg: str):
+        instruct_summarize = f"{bidding_history}\n\n{hammer_msg}\n{win_lose_msg}"
+        return instruct_summarize
+    
+    def summarize(self, instruct_summarize: str):
+        self.dialogue_history += [
+            HumanMessage(content=instruct_summarize),
+            AIMessage(content='Noted.')
+        ]
+        self.budget_history.append(self.budget)
+        self.profit_history.append(self.profit)
+        return ''
+    
+    def get_replan_instruct(self):
+        return ''
+
+    def replan(self, instruct_replan):
+        self.withdraw = False
+        self.cur_item_id += 1
+        return ''
+    
+    def to_monitors(self, as_json=False):
+        items_won = []
+        for item, bid in self.items_won:
+            items_won.append([str(item), bid, item.true_value])
+        if as_json:
+            return {
+                'auction_hash': self.auction_hash,
+                'bidder_name': self.name,
+                'human_name': self.human_name,
+                'model_name': self.model_name,
+                'budget': self.original_budget,
+                'money_left': self.budget,
+                'profit': self.profit,
+                'items_won': items_won,
+                'engagement_count': self.engagement_count,
+            }
+        else:
+            return [
+                self.budget, 
+                self.profit, 
+                items_won, 
+                0, 
+                0, 
+                round(self.failed_bid_cnt / (self.total_bid_cnt+1e-8), 2), 
+                0, 
+                0, 
+                self.engagement_count,
+                draw_plot(f"{self.name} ({self.model_name})", self.budget_history, self.profit_history), 
+                [],
+                [],
+                [], 
+                []
+            ]
+    

src/item_base.py

@@ -0,0 +1,50 @@
+import sys
+sys.path.append('..')
+from utils import LoadJsonL
+
+
+class Item():
+    def __init__(self, id: int, name: str, price: int, desc: str, true_value: int):
+        self.id = id
+        self.name = name
+        self.price = price
+        self.desc = desc
+        self.true_value = true_value
+        self._original_price = price
+
+    def get_desc(self):
+        return f"{self.name}, starting at ${int(self.price)}."
+
+    def __repr__(self):
+        return f"{self.name}"
+    
+    def __str__(self):
+        return f"{self.name}"
+    
+    def info(self):
+        return f"{self.name}: ${int(self.price)} to ${self.true_value}."
+
+    def lower_price(self, percentage: float = 0.2):
+        # lower starting price by 20%
+        self.price = int(self.price * (1 - percentage))
+    
+    def reset_price(self):
+        self.price = self._original_price
+
+
+def create_items(item_info_jsl):
+    '''
+    item_info: a list of dict (name, price, desc, id)
+    '''
+    item_info_jsl = LoadJsonL(item_info_jsl)
+    item_list = []
+    for info in item_info_jsl:
+        item_list.append(Item(**info))
+    return item_list
+
+
+def item_list_equal(items_1: list, items_2: list):
+    # could be a list of strings (names) or a list of Items
+    item_1_names = [item.name if isinstance(item, Item) else item for item in items_1]
+    item_2_names = [item.name if isinstance(item, Item) else item for item in items_2]
+    return set(item_1_names) == set(item_2_names)

src/prompt_base.py

@@ -0,0 +1,349 @@
+# for bidder
+SYSTEM_MESSAGE = """
+You are {name}, who is attending an ascending-bid auction as a bidder. This auction will have some other bidders to compete with you in bidding wars. The price is gradually raised, bidders drop out until finally only one bidder remains, and that bidder wins the item at this final price. Remember: {desire_desc}.
+
+Here are some must-know rules for this auction:
+
+1. Item Values: The true value of an item means its resale value in the broader market, which you don't know. You will have a personal estimation of the item value. However, note that your estimated value could deviate from the true value, due to your potential overestimation or underestimation of this item.
+2. Winning Bid: The highest bid wins the item. Your profit from winning an item is determined by the difference between the item's true value and your winning bid. You should try to win an item at a bid as minimal as possible to save your budget.
+""".strip()
+
+
+_LEARNING_STATEMENT = " and your learnings from previous auctions"
+
+
+INSTRUCT_PLAN_TEMPLATE = """
+As {bidder_name}, you have a total budget of ${budget}. This auction has a total of {item_num} items to be sequentially presented, they are:
+{items_info}
+
+---
+
+Please plan for your bidding strategy for the auction based on the information{learning_statement}. A well-thought-out plan positions you advantageously against competitors, allowing you to allocate resources effectively. With a clear strategy, you can make decisions rapidly and confidently, especially under the pressure of the auction environment. Remember: {desire_desc}. 
+
+After articulate your thinking, in you plan, assign a priority level to each item. Present the priorities for all items in a JSON format, each item should be represented as a key-value pair, where the key is the item name and the value is its priority on the scale from 1-3. An example output is: {{"Fixture Y": 3, "Module B": 2, "Product G": 2}}. The descriptions of the priority scale of items are as follows.
+    * 1 - This item is the least important. Consider giving it up if necessary to save money for the rest of the auction.
+    * 2 - This item holds value but isn't a top priority for the bidder. Could bid on it if you have enough budget.
+    * 3 - This item is of utmost importance and is a top priority for the bidder in the rest of the auction.
+""".strip()
+
+
+INSTRUCT_BID_TEMPLATE = """
+Now, the auctioneer says: "{auctioneer_msg}"
+
+---
+
+As {bidder_name}, you have to decide whether to bid on this item or withdraw and explain why, according to your plan{learning_statement}. Remember, {desire_desc}.
+
+Here are some common practices of bidding:
+1. Showing your interest by bidding with or slightly above the starting price of this item, then gradually increase your bid.
+2. Think step by step of the pros and cons and the consequences of your action (e.g., remaining budget in future bidding) in order to achieve your primary objective.
+
+Give your reasons first, then make your final decision clearly. You should either withdraw (saying "I'm out!") or make a higher bid for this item (saying "I bid $xxx!").
+""".strip()
+
+
+INSTRUCT_SUMMARIZE_TEMPLATE = """
+Here is the history of the bidding war of {cur_item}:
+"{bidding_history}"
+
+The auctioneer concludes: "{hammer_msg}" 
+
+---
+
+{win_lose_msg} 
+As {bidder_name}, you have to update the status of the auction based on this round of bidding. Here's your previous status:
+```
+{prev_status}
+```
+
+Summarize the notable behaviors of all bidders in this round of bidding for future reference. Then, update the status JSON regarding the following information:
+- 'remaining_budget': The remaining budget of you, expressed as a numerical value.
+- 'total_profits': The total profits achieved so far for each bidder, where a numerical value following a bidder's name. No equation is needed, just the numerical value.
+- 'winning_bids': The winning bids for every item won by each bidder, listed as key-value pairs, for example, {{"bidder_name": {{"item_name_1": winning_bid}}, {{"item_name_2": winning_bid}}, ...}}. If a bidder hasn't won any item, then the value for this bidder should be an empty dictionary {{}}.
+- Only include the bidders mentioned in the given text. If a bidder is not mentioned (e.g. Bidder 4 in the following example), then do not include it in the JSON object.
+
+After summarizing the bidding history, you must output the current status in a parsible JSON format. An example output looks like:
+```
+{{"remaining_budget": 8000, "total_profits": {{"Bidder 1": 1300, "Bidder 2": 1800, "Bidder 3": 0}}, "winning_bids": {{"Bidder 1": {{"Item 2": 1200, "Item 3": 1000}}, "Bidder 2": {{"Item 1": 2000}}, "Bidder 3": {{}}}}}}
+```
+""".strip()
+
+
+INSTRUCT_LEARNING_TEMPLATE = """
+Review and reflect on the historical data provided from a past auction. 
+
+{past_auction_log}
+
+Here are your past learnings:
+
+{past_learnings}
+
+Based on the auction log, formulate or update your learning points that could be advantageous to your strategies in the future. Your learnings should be strategic, and of universal relevance and practical use for future auctions. Consolidate your learnings into a concise numbered list of sentences.
+""".strip()
+
+
+INSTRUCT_REPLAN_TEMPLATE = """
+The current status of you and other bidders is as follows:
+```
+{status_quo}
+```
+
+Here are the remaining items in the rest of the auction:
+"{remaining_items_info}"
+
+As {bidder_name}, considering the current status{learning_statement}, review your strategies. Adjust your plans based on the outcomes and new information to achieve your primary objective. This iterative process ensures that your approach remains relevant and effective. Please do the following:
+1. Always remember: {desire_desc}.
+2. Determine and explain if there's a need to update the priority list of remaining items based on the current status. 
+3. Present the updated priorities in a JSON format, each item should be represented as a key-value pair, where the key is the item name and the value is its priority on the scale from 1-3. An example output is: {{"Fixture Y": 3, "Module B": 2, "Product G": 2}}. The descriptions of the priority scale of items are as follows.
+    * 1 - This item is the least important. Consider giving it up if necessary to save money for the rest of the auction.
+    * 2 - This item holds value but isn't a top priority for the bidder. Could bid on it if you have enough budget.
+    * 3 - This item is of utmost importance and is a top priority for the bidder in the rest of the auction.
+""".strip()
+
+
+# for auctioneer
+PARSE_BID_INSTRUCTION = """
+Your task is to parse a response from a bidder in an auction, and extract the bidding price from the response. Here are the rules:
+- If the language model decides to withdraw from the bidding (e.g., saying "I'm out!"), output -1.
+- If a bidding price is mentioned (e.g., saying "I bid $xxx!"), output that price number (e.g., $xxx).
+Here is the response:
+
+{response}
+
+Don't say anything else other than just a number: either the bidding price (e.g., $xxx, with $) or -1.
+""".strip()
+
+
+AUCTION_HISTORY = """
+## Auction Log
+
+### 1. Equipment E, starting at $5000.
+
+#### 1st bid:
+* Bidder 1: $5500
+* Bidder 2: $5100
+* Bidder 3: $5100
+* Bidder 4: $5500
+* Bidder 5: $6000
+
+#### 2nd bid:
+* Bidder 1: Withdrew
+* Bidder 2: Withdrew
+* Bidder 3: Withdrew
+* Bidder 4: $6500
+
+#### 3rd bid:
+* Bidder 5: $7000
+
+#### 4th bid:
+* Bidder 4: Withdrew
+
+#### Hammer price (true value):
+* Bidder 5: $7000 ($10000)
+
+### 2. Thingamajig C, starting at $1000.
+
+#### 1st bid:
+* Bidder 1: $1500
+* Bidder 2: Withdrew
+* Bidder 3: Withdrew
+* Bidder 4: Withdrew
+* Bidder 5: Withdrew
+
+#### Hammer price (true value):
+* Bidder 1: $1500 ($2000)
+
+### 3. Component S, starting at $1000.
+
+#### 1st bid:
+* Bidder 1: $1200
+* Bidder 2: $1050
+* Bidder 3: $1000
+* Bidder 4: Withdrew
+* Bidder 5: $1200
+
+#### 2nd bid:
+* Bidder 2: Withdrew
+* Bidder 3: $1300
+* Bidder 5: $1300
+
+#### 3rd bid:
+* Bidder 1: Withdrew
+* Bidder 3: $1400
+
+#### 4th bid:
+* Bidder 5: Withdrew
+
+#### Hammer price (true value):
+* Bidder 3: $1400 ($2000)
+
+### 4. Implement G, starting at $1000.
+
+#### 1st bid:
+* Bidder 1: $1100
+* Bidder 2: $1000
+* Bidder 3: $1100
+* Bidder 4: Withdrew
+* Bidder 5: $1500
+
+#### 2nd bid:
+* Bidder 1: Withdrew
+* Bidder 2: Withdrew
+* Bidder 3: $1600
+
+#### 3rd bid:
+* Bidder 5: $1700
+
+#### 4th bid:
+* Bidder 3: Withdrew
+
+#### Hammer price (true value):
+* Bidder 5: $1700 ($2000)
+
+### 5. Piece T, starting at $1000.
+
+#### 1st bid:
+* Bidder 1: $1100
+* Bidder 2: $1000
+* Bidder 3: $1100
+* Bidder 4: Withdrew
+* Bidder 5: $1200
+
+#### 2nd bid:
+* Bidder 1: Withdrew
+* Bidder 2: $1300
+* Bidder 3: $1300
+
+#### 3rd bid:
+* Bidder 2: $1400
+* Bidder 5: Withdrew
+
+#### 4th bid:
+* Bidder 3: $1500
+
+#### 5th bid:
+* Bidder 2: Withdrew
+
+#### Hammer price (true value):
+* Bidder 3: $1500 ($2000)
+
+### 6. Doodad D, starting at $1000.
+
+#### 1st bid:
+* Bidder 1: Withdrew
+* Bidder 2: $1000
+* Bidder 3: Withdrew
+* Bidder 4: $1010
+* Bidder 5: $1300
+
+#### 2nd bid:
+* Bidder 2: Withdrew
+* Bidder 4: Withdrew
+
+#### Hammer price (true value):
+* Bidder 5: $1300 ($2000)
+
+### 7. Gizmo F, starting at $1000.
+
+#### 1st bid:
+* Bidder 1: $1100
+* Bidder 2: $1000
+* Bidder 3: Withdrew
+* Bidder 4: Withdrew
+* Bidder 5: Withdrew
+
+#### 2nd bid:
+* Bidder 2: $1200
+
+#### 3rd bid:
+* Bidder 1: Withdrew
+
+#### Hammer price (true value):
+* Bidder 2: $1200 ($2000)
+
+### 8. Widget A, starting at $1000.
+
+#### 1st bid:
+* Bidder 1: $2200
+* Bidder 2: $1000
+* Bidder 3: $1100
+* Bidder 4: Withdrew
+* Bidder 5: Withdrew
+
+#### 2nd bid:
+* Bidder 2: Withdrew
+* Bidder 3: Withdrew
+
+#### Hammer price (true value):
+* Bidder 1: $2200 ($2000)
+
+### 9. Gadget B, starting at $1000.
+
+#### 1st bid:
+* Bidder 1: $1200
+* Bidder 2: Withdrew
+* Bidder 3: Withdrew
+* Bidder 4: $1000
+* Bidder 5: Withdrew
+
+#### 2nd bid:
+* Bidder 4: Withdrew
+
+#### Hammer price (true value):
+* Bidder 1: $1200 ($2000)
+
+### 10. Mechanism J, starting at $5000.
+
+#### 1st bid:
+* Bidder 1: Withdrew
+* Bidder 2: $5000
+* Bidder 3: $5100
+* Bidder 4: $6000
+* Bidder 5: Withdrew
+
+#### 2nd bid:
+* Bidder 2: $6500
+* Bidder 3: $6500
+
+#### 3rd bid:
+* Bidder 3: $7000
+* Bidder 4: $7000
+
+#### 4th bid:
+* Bidder 2: $7500
+* Bidder 3: Withdrew
+
+#### 5th bid:
+* Bidder 4: $8000
+
+#### 6th bid:
+* Bidder 2: $8500
+
+#### 7th bid:
+* Bidder 4: Withdrew
+
+#### Hammer price (true value):
+* Bidder 2: $8500 ($10000)
+
+## Personal Report
+
+* Bidder 1, starting with $10000, has won 3 items in this auction, with a total profit of $1100.:
+  * Won Thingamajig C at $1500 over $1000, with a true value of $2000.
+  * Won Widget A at $2200 over $1000, with a true value of $2000.
+  * Won Gadget B at $1200 over $1000, with a true value of $2000.
+
+* Bidder 2, starting with $10000, has won 2 items in this auction, with a total profit of $2300.:
+  * Won Gizmo F at $1200 over $1000, with a true value of $2000.
+  * Won Mechanism J at $8500 over $5000, with a true value of $10000.
+
+* Bidder 3, starting with $10000, has won 2 items in this auction, with a total profit of $1100.:
+  * Won Component S at $1400 over $1000, with a true value of $2000.
+  * Won Piece T at $1500 over $1000, with a true value of $2000.
+
+* Bidder 4, starting with $10000, has won 0 items in this auction, with a total profit of $0.:
+
+* Bidder 5, starting with $10000, has won 3 items in this auction, with a total profit of $4000.:
+  * Won Equipment E at $7000 over $5000, with a true value of $10000.
+  * Won Implement G at $1700 over $1000, with a true value of $2000.
+  * Won Doodad D at $1300 over $1000, with a true value of $2000.
+""".strip()

utils.py

@@ -0,0 +1,73 @@
+import ujson as json
+import re
+import traceback
+
+
+def trace_back(error_msg):
+    exc = traceback.format_exc()
+    msg = f'[Error]: {error_msg}.\n[Traceback]: {exc}'
+    return msg
+
+
+def extract_numbered_list(paragraph):
+    # Updated regular expression to match numbered list
+    # It looks for:
+    # - start of line
+    # - one or more digits
+    # - a period or parenthesis
+    # - optional whitespace
+    # - any character (captured in a group) until the end of line or a new number
+    pattern = r"^\s*(\d+[.)]\s?.*?)(?=\s*\d+[.)]|$)"
+    
+    matches = re.findall(pattern, paragraph, re.DOTALL | re.MULTILINE)
+    return [match.strip() for match in matches]
+
+
+def chunks(lst, n):
+    """Yield successive n-sized chunks from lst."""
+    for i in range(0, len(lst), n):
+        yield lst[i : i + n]
+
+
+def reset_state_list(*states):
+    empty = [None for _ in states[1:]]
+    return [[]] + empty
+
+
+def LoadJsonL(filename):
+    if isinstance(filename, str):
+        jsl = []
+        with open(filename) as f:
+            for line in f:
+                jsl.append(json.loads(line))
+        return jsl
+    else:
+        return filename
+
+
+def extract_jsons_from_text(text):
+    json_dicts = []
+    stack = []
+    start_index = None
+    
+    for i, char in enumerate(text):
+        if char == '{':
+            stack.append(char)
+            if start_index is None:
+                start_index = i
+        elif char == '}':
+            if stack:
+                stack.pop()
+            if not stack and start_index is not None:
+                json_candidate = text[start_index:i+1]
+                try:
+                    parsed_json = json.loads(json_candidate)
+                    json_dicts.append(parsed_json)
+                    start_index = None
+                except json.JSONDecodeError:
+                    pass
+                finally:
+                    start_index = None
+    
+    if len(json_dicts) == 0: json_dicts = [{}]
+    return json_dicts