feat: implement negotiation environment wrapper and LLM-based inference script

env_wrapper.py

@@ -0,0 +1,100 @@
+import random
+
+class Opponent:
+    def __init__(self, type_str, value, role):
+        self.type = type_str
+        self.opponent_value = value
+        self.opponent_role = role
+        if type_str == "greedy":
+            self.r, self.alpha, self.patience, self.epsilon = 0.05, 0.7, 10, 5
+        elif type_str == "fair":
+            self.r, self.alpha, self.patience, self.epsilon = 0.15, 0.4, 7, 10
+        elif type_str == "impatient":
+            self.r, self.alpha, self.patience, self.epsilon = 0.25, 0.2, 3, 15
+        else:
+            self.r, self.alpha, self.patience, self.epsilon = 0.15, 0.4, 7, 10
+        self.concession_rate = self.r
+
+    def get_response(self, round_num, current_offer, agent_offer, agent_action_type):
+        if agent_action_type != "OFFER":
+            return "REJECT", 0
+
+        if self.opponent_role == "seller" and agent_offer >= self.opponent_value: 
+            return "ACCEPT", agent_offer
+        if self.opponent_role == "buyer" and agent_offer <= self.opponent_value: 
+            return "ACCEPT", agent_offer
+
+        if round_num > self.patience:
+            self.concession_rate = min(0.4, self.concession_rate + 0.05)
+
+        target = self.opponent_value
+        delta = target - current_offer
+        next_offer = current_offer + self.concession_rate * delta
+        next_offer = (1.0 - self.alpha) * next_offer + self.alpha * current_offer
+        next_offer += random.randint(-self.epsilon, self.epsilon)
+        next_offer = max(100, min(1000, int(next_offer)))
+        return "OFFER", next_offer
+
+class EnvWrapper:
+    def __init__(self, opp_type="fair", a_val=800, o_val=500, agent_role="buyer"):
+        self.agent_value = a_val
+        self.opponent_value = o_val
+        self.role = agent_role
+        self.opp_role = "seller" if agent_role == "buyer" else "buyer"
+        self.opp = Opponent(opp_type, o_val, self.opp_role)
+        self.max_rounds = 20
+        self.reset()
+        
+    def reset(self):
+        self.round = 0
+        if self.role == "buyer":
+            self.current_offer = self.agent_value + 200
+        else:
+            self.current_offer = max(100, self.agent_value - 200)
+        self.last_opp_action = "START"
+        self.last_opp_offer = self.current_offer
+
+    def step(self, action_str, action_price=0):
+        self.round += 1
+        aggressive = False
+        done = False
+        reward = 0.0
+        
+        if action_str == "ACCEPT":
+            deal_price = self.last_opp_offer
+            done = True
+            profit = deal_price - self.agent_value if self.role == "seller" else self.agent_value - deal_price
+            t_factor = 1.0 - (self.round / self.max_rounds)
+            reward = profit * t_factor
+            if profit < 0: reward -= 20
+            
+        elif action_str == "REJECT":
+            reward = -50.0
+            done = True
+            
+        elif action_str.startswith("OFFER"):
+            aggressive = abs(action_price - self.opponent_value) > 150
+            opp_action, opp_price = self.opp.get_response(self.round, self.current_offer, action_price, "OFFER")
+            if opp_action == "ACCEPT":
+                deal_price = action_price
+                done = True
+                self.last_opp_action = "ACCEPT"
+                self.last_opp_offer = deal_price
+                
+                profit = deal_price - self.agent_value if self.role == "seller" else self.agent_value - deal_price
+                t_factor = 1.0 - (self.round / self.max_rounds)
+                reward = profit * t_factor
+                if profit < 0: reward -= 20
+                if aggressive: reward -= 2
+            else:
+                self.current_offer = opp_price
+                self.last_opp_action = "OFFER"
+                self.last_opp_offer = opp_price
+                if self.round >= self.max_rounds:
+                    reward = -50.0
+                    done = True
+        
+        if not done:
+            reward = 0.0
+            
+        return reward, done

inference.py

@@ -0,0 +1,111 @@
+import os
+import re
+import sys
+from openai import OpenAI
+from env_wrapper import EnvWrapper
+
+def main():
+    api_base_url = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+    model_name = os.getenv("MODEL_NAME", "meta-llama/Meta-Llama-3-8B-Instruct")
+    hf_token = os.getenv("HF_TOKEN")
+    
+    if not hf_token:
+        print("ERROR: HF_TOKEN environment variable is not set.")
+        sys.exit(1)
+
+    env = EnvWrapper(opp_type="fair", a_val=300, o_val=700, agent_role="buyer")
+    env.max_rounds = 4
+    env.reset()
+    
+    print(f"[START] task=negotiation env=custom model={model_name}")
+    
+    client = OpenAI(base_url=api_base_url, api_key=hf_token)
+    
+    done = False
+    step_n = 0
+    rewards = []
+    
+    while not done and step_n < env.max_rounds:
+        step_n += 1
+        
+        prompt = f"""You are negotiating as a {env.role}.
+State:
+* Current offer: {env.current_offer}
+* Round: {env.round}
+* Max rounds: {env.max_rounds}
+
+Choose ONE:
+* OFFER <price> (Preferred: counter-offer if you do not like the price!)
+* ACCEPT
+* REJECT"""
+        
+        action_str = "REJECT"
+        action_price = 0
+        error_msg = "null"
+        
+        try:
+            response = client.chat.completions.create(
+                model=model_name,
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=20,
+                temperature=0.3
+            )
+            llm_text = response.choices[0].message.content.strip()
+            
+            match = re.search(r'(OFFER\s+\d+|ACCEPT|REJECT)', llm_text, re.IGNORECASE)
+            if match:
+                action_str = match.group(1).upper()
+            else:
+                error_msg = "parsing failed, retrying"
+                response = client.chat.completions.create(
+                    model=model_name,
+                    messages=[{"role": "user", "content": prompt}, {"role": "assistant", "content": llm_text}, {"role": "user", "content": "Output strictly ONLY ONE of: 'OFFER <price>', 'ACCEPT', or 'REJECT'."}],
+                    max_tokens=15,
+                    temperature=0.1
+                )
+                llm_text2 = response.choices[0].message.content.strip()
+                match2 = re.search(r'(OFFER\s+\d+|ACCEPT|REJECT)', llm_text2, re.IGNORECASE)
+                if match2:
+                    action_str = match2.group(1).upper()
+                    error_msg = "null"
+                else:
+                    action_str = "REJECT"
+                    error_msg = "parse error on retry, defaulting to REJECT"
+        except Exception as e:
+            error_msg = "API_Error"
+            action_str = "REJECT"
+            
+        if action_str.startswith("OFFER"):
+            try:
+                action_price = int(action_str.split()[1])
+            except ValueError:
+                action_str = "REJECT"
+                action_price = 0
+                error_msg = "invalid price format"
+        elif action_str == "ACCEPT":
+            action_str = "ACCEPT"
+        elif action_str == "REJECT":
+            action_str = "REJECT"
+            
+        # Strip potential garbage
+        if "OFFER" in action_str:
+            action_str = f"OFFER {action_price}"
+            
+        reward, d = env.step(action_str, action_price)
+        done = d
+        rewards.append(reward)
+        
+        print(f"[STEP] step={step_n} action={action_str} reward={reward:.2f} done={str(done).lower()} error={error_msg}")
+
+    
+    # SCORING
+    max_possible_reward = float(abs(env.agent_value - env.opponent_value))
+    score = sum(rewards) / max_possible_reward if max_possible_reward > 0 else 0.0
+    score = max(0.0, min(1.0, score))
+    success = score > 0.3
+    
+    rewards_str = ",".join([f"{r:.2f}" for r in rewards])
+    print(f"[END] success={str(success).lower()} steps={step_n} score={score:.4f} rewards={rewards_str}")
+
+if __name__ == "__main__":
+    main()