Initialize OpenEnv Customer Support Project

.gitignore

@@ -0,0 +1,23 @@
+# Environments
+.env
+.venv/
+venv/
+ENV/
+env/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# Node
+node_modules/
+
+# Next.js
+.next/
+out/
+build/
+
+# Mac
+.DS_Store

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10-slim
+
+# Hugging Face explicitly requires a non-root user mapped to 1000
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY --chown=user . $HOME/app
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,83 @@
+# AI Customer Support Decision-Making Environment (OpenEnv)
+
+## Environment Description
+This is a mathematically constrained OpenEnv Customer Support simulation. It simulates real-world workflows encompassing complex decision-making processes for an AI customer support agent. The environment maps dynamic ticket properties (sentiment, issues) and evaluates sequential agent logic to determine correct problem resolutions across constrained pipelines.
+
+## Action Space
+The AI agent interacts with the environment sequentially by emitting precise JSON payloads defined dynamically inside string schemas.
+
+**Available Actions:**
+- `classify_ticket`: Evaluates string. Payload mapping: `{"classification": "refund" | "general_inquiry" | "login_issue" | "feedback"}`
+- `assign_priority`: Assigns structural tier. Payload mapping: `{"priority": "low" | "medium" | "high"}`
+- `generate_response`: Drafts contextual replies to tickets. Enforces checking `sentiment` logic constraint requirements (e.g., apologies). Payload mapping: `{"response": "<text>"}`
+- `escalate`: Maps directly to manual priority bypass. Empty payload: `{}`
+- `resolve`: Pipeline completion call mapped to constraints checking complete scenario data. Empty payload: `{}`
+
+## Observation Space
+State mapping delivers deterministic JSON payload snapshots back to the interacting agent across the workflow sequence.
+
+**State Fields Include:**
+- `ticket_text`: Read-only simulated user input sequence string.
+- `sentiment`: Customer evaluation mapped (e.g., `angry`, `neutral`, `happy`).
+- `priority`: Active assignment tracker (`null` until categorized).
+- `status`: Global environment variable matching `open` or `closed` lifecycle mapping.
+- `steps_taken`: Numeric iteration tracker mapping execution costs.
+- `classification`: Evaluated class.
+- `response`: Text payload caching assigned generated scripts.
+
+## Task Descriptions
+The environment exposes explicit evaluation goals mapping standard deterministic task metrics (`0.0` - `1.0`):
+
+- **EASY** (`task_easy_1`): Only classify the issue correctly. 
+- **MEDIUM** (`task_medium_1`): Classify the ticket completely and generate an appropriate text response (measuring conditional logic like providing empathy for an explicitly 'angry' sentiment).
+- **HARD** (`task_hard_1`): The agent structurally navigates the entire pipeline: 1. Correctly classify mapping 2. Assign priority mappings accurately 3. Emit valid appropriate responses 4. Correctly resolve the closed ticket state.
+
+## Reward Design
+Densely structured continuous math map designed for precision agent behavior shaping:
+
+**Sequential Rewards (Partial Progress):**
+- **`+0.3`**: Correct ticket classification.
+- **`+0.2`**: Accurate priority assignment.
+- **`+0.2`**: Successful appropriate response generation.
+- **`+0.3`**: Officially verified constraint-approved ticket structural resolution.
+
+**Penalties:**
+- **`-0.2`**: Punishes specifically wrong actions (assigning the wrong classification, failing empathy mappings, bypassing procedures).  
+- **`-0.1`**: Punishment for immediately duplicating/repeating explicit prior script actions iteratively.
+- **`-0.1`**: Incurred purely per sequential step count scaling execution delays to promote processing speed organically.
+
+## Setup Instructions
+Use pip explicitly isolating a lightweight requirement instance natively natively configuring local systems:
+
+```bash
+pip install -r requirements.txt
+```
+
+Start the interactive API server natively linking locally:
+```bash
+uvicorn app.main:app --host 0.0.0.0 --port 7860
+```
+### Running Via Docker (Hugging Face Ready)
+This build incorporates standard non-root target configs enabling seamless capability deploys onto HF. 
+```bash
+docker build -t openenv-support .
+docker run -p 7860:7860 openenv-support
+```
+
+## How to Run Inference (Hugging Face / OpenAI)
+Trigger our automated evaluate pipeline structurally invoking evaluations cleanly recording constraints logic directly via precise print hooks dynamically validating execution.
+
+```bash
+export MODEL_NAME="meta-llama/Meta-Llama-3-8B-Instruct"
+export HF_TOKEN="hf_..."
+python inference.py --task task_hard_1
+```
+
+## Push to Hugging Face Hub
+A helper script allows you to rapidly publish your entire codebase straight out into your Hugging Face space repository. 
+
+Run the automated publisher to upload this space seamlessly into `vivekvish2004/openenv-customer-support`:
+```bash
+python push_to_hf.py
+```
+*(This gracefully detects existing tokens and ignores large bloat directories like node_modules to ensure a fast, clean upload!)*

app/__init__.py

@@ -0,0 +1 @@
+"""Init module."""

app/env.py

@@ -0,0 +1,167 @@
+import random
+import copy
+from typing import Tuple
+from app.models import Action, Observation, Reward
+
+# Pre-defined real-world support tickets for the workflow simulation
+SCENARIOS = [
+    {
+        "ticket_text": "I bought a premium subscription but it's not working. I want my money back right now!",
+        "sentiment": "angry",
+        "expected_classification": "refund",
+        "expected_priority": "high",
+    },
+    {
+        "ticket_text": "How do I change my profile picture? I tried looking in the settings but couldn't find it.",
+        "sentiment": "neutral",
+        "expected_classification": "general_inquiry",
+        "expected_priority": "low",
+    },
+    {
+        "ticket_text": "I can't log into my account, and I have a huge presentation in 10 minutes that needs the data!",
+        "sentiment": "angry",
+        "expected_classification": "login_issue",
+        "expected_priority": "high",
+    },
+    {
+        "ticket_text": "Thank you so much for fixing the bug! Everything is running perfectly today.",
+        "sentiment": "happy",
+        "expected_classification": "feedback",
+        "expected_priority": "low",
+    }
+]
+
+class CustomerSupportEnv:
+    def __init__(self):
+        """Initialize the AI Customer Support environment."""
+        self.current_state = None
+        self.ground_truth = None
+        self.max_steps = 10
+        self.current_step = 0
+        self.actions_taken = set()
+
+    def reset(self) -> Observation:
+        """Reset the environment to a new random customer support ticket."""
+        self.ground_truth = random.choice(SCENARIOS)
+        self.current_step = 0
+        self.actions_taken = set()
+        
+        # State strictly matching requirements
+        self.current_state = {
+            "ticket_text": self.ground_truth["ticket_text"],
+            "sentiment": self.ground_truth["sentiment"],
+            "priority": None,        # AI will assign (low / medium / high)
+            "status": "open",        # Track ticket lifecycle
+            "steps_taken": 0,
+            "classification": None,  # AI will classify
+            "response": None         # AI's generated reply
+        }
+        
+        return self.state()
+        
+    def state(self) -> Observation:
+        """Return the current state of the environment."""
+        return Observation(
+            state=self.current_state,
+            info={"max_steps": self.max_steps}
+        )
+
+    def step(self, action: Action) -> Tuple[Observation, Reward, bool, dict]:
+        """Apply an action to process the ticket workflow and evaluate using dense rewards."""
+        self.current_step += 1
+        self.current_state["steps_taken"] += 1
+        
+        reward_val = 0.0
+        is_terminal = False
+        message = ""
+        
+        a_type = action.action_type
+        payload = action.payload
+        
+        # Ensure ticket is open to take steps
+        if self.current_state["status"] == "closed":
+            return self.state(), Reward(value=-0.2, is_terminal=True), True, {"error": "Ticket is already closed"}
+
+        # Penalize repeated actions (-0.1)
+        if a_type in self.actions_taken:
+            reward_val -= 0.1
+            message += "Repeated action penalty. "
+        else:
+            self.actions_taken.add(a_type)
+            
+        # Penalize taking too many steps (-0.1 step cost)
+        reward_val -= 0.1
+
+        # Simulate the structured workflows with standard explicit dense reward triggers
+        if a_type == "classify_ticket":
+            category = payload.get("classification")
+            self.current_state["classification"] = category
+            if category == self.ground_truth["expected_classification"]:
+                reward_val += 0.3 # Correct classification
+                message += "Correct classification."
+            else:
+                reward_val -= 0.2 # Wrong action penalty
+                message += "Incorrect classification."
+                
+        elif a_type == "assign_priority":
+            level = payload.get("priority")
+            self.current_state["priority"] = level
+            if level == self.ground_truth["expected_priority"]:
+                reward_val += 0.2 # Correct priority
+                message += "Correct priority assignment."
+            else:
+                reward_val -= 0.2 # Wrong action penalty
+                message += "Suboptimal priority assignment."
+                
+        elif a_type == "generate_response":
+            response_text = payload.get("response")
+            self.current_state["response"] = response_text
+            
+            if self.current_state["sentiment"] == "angry" and "sorry" not in response_text.lower():
+                reward_val -= 0.2 # Wrong action penalty (lacked empathy)
+                message += "Response lacked empathy for an angry customer."
+            else:
+                reward_val += 0.2 # Useful response
+                message += "Useful response generated."
+                
+        elif a_type == "escalate":
+            if self.current_state["sentiment"] == "angry" and self.ground_truth["expected_priority"] == "high":
+                reward_val += 0.3 # Act as successful resolution of urgent cases
+                message += "Successfully escalated urgent issue."
+            else:
+                reward_val -= 0.2 # Wrong action penalty
+                message += "Wrong action: Unnecessary escalation for low-priority issue."
+            self.current_state["status"] = "closed"
+            is_terminal = True
+            
+        elif a_type == "resolve":
+            if not self.current_state["classification"] or not self.current_state["priority"] or not self.current_state["response"]:
+                reward_val -= 0.2 # Wrong action penalty
+                message += "Wrong action: Attempted resolution without completing workflow steps."
+            else:
+                reward_val += 0.3 # Resolution success
+                message += "Ticket resolved successfully."
+            
+            self.current_state["status"] = "closed"
+            is_terminal = True
+            
+        else:
+            reward_val -= 0.2 # Wrong action explicitly
+            message += f"Wrong action: Unknown action '{a_type}'."
+            
+        # Failsafe limit checking
+        if self.current_step >= self.max_steps and not is_terminal:
+             is_terminal = True
+             if self.current_state["status"] == "open":
+                 self.current_state["status"] = "closed"
+                 
+        obs = self.state()
+        reward = Reward(value=reward_val, is_terminal=is_terminal)
+        
+        info = {
+            "message": message,
+            "expected_classification": self.ground_truth["expected_classification"],
+            "expected_priority": self.ground_truth["expected_priority"]
+        }
+        
+        return obs, reward, is_terminal, info

app/grader.py

@@ -0,0 +1,80 @@
+from typing import Dict, Any, List
+
+def score_easy(state: Dict[str, Any], ground_truth: Dict[str, Any]) -> float:
+    """EASY: Only classify issue correctly (1.0 or 0.0)"""
+    if state.get("classification") == ground_truth.get("expected_classification"):
+        return 1.0
+    return 0.0
+
+def score_medium(state: Dict[str, Any], ground_truth: Dict[str, Any]) -> float:
+    """MEDIUM: classify (0.5) + generate correct response (0.5)"""
+    score = 0.0
+    
+    # 1. Classification
+    if state.get("classification") == ground_truth.get("expected_classification"):
+        score += 0.5
+        
+    # 2. Response
+    response = state.get("response")
+    if response:
+        # Check empathy constraint for angry customers
+        if state.get("sentiment") == "angry" and "sorry" not in response.lower():
+            pass # Missing empathy
+        else:
+            score += 0.5
+            
+    return score
+
+def score_hard(state: Dict[str, Any], ground_truth: Dict[str, Any]) -> float:
+    """HARD: classify (0.25) -> prioritize (0.25) -> respond (0.25) -> resolve (0.25)"""
+    score = 0.0
+    
+    # 1. Classification
+    if state.get("classification") == ground_truth.get("expected_classification"):
+        score += 0.25
+        
+    # 2. Prioritize
+    if state.get("priority") == ground_truth.get("expected_priority"):
+        score += 0.25
+        
+    # 3. Respond
+    response = state.get("response")
+    if response:
+        if state.get("sentiment") == "angry" and "sorry" not in response.lower():
+            pass # Missing empathy
+        else:
+            score += 0.25
+            
+    # 4. Resolve
+    if state.get("status") == "closed":
+        score += 0.25
+        
+    return score
+
+def score_episode(task_difficulty: str, history: List[Dict[str, Any]], ground_truth: Dict[str, Any]) -> float:
+    """
+    Deterministic scoring logic for evaluated episode. Returns a float between 0.0 and 1.0.
+    """
+    if not history:
+        return 0.0
+        
+    # Analyze the final step in the history
+    final_step = history[-1]
+    
+    # Support various OpenEnv standard observation dictionary shapes
+    if "observation" in final_step and isinstance(final_step["observation"], dict) and "state" in final_step["observation"]:
+        final_state = final_step["observation"]["state"]
+    elif "state" in final_step:
+        final_state = final_step["state"]
+    else:
+        final_state = final_step
+
+    diff = task_difficulty.upper()
+    if diff == "EASY":
+        return score_easy(final_state, ground_truth)
+    elif diff == "MEDIUM":
+        return score_medium(final_state, ground_truth)
+    elif diff == "HARD":
+        return score_hard(final_state, ground_truth)
+        
+    return 0.0

app/main.py

@@ -0,0 +1,99 @@
+from fastapi import FastAPI, HTTPException, Query
+from app.env import CustomerSupportEnv
+from app.models import Action, Observation
+from app.tasks import get_all_tasks
+from app.grader import score_episode
+
+app = FastAPI(title="OpenEnv Customer Support API")
+
+# Global singleton for the environment state lifecycle
+env_instance = CustomerSupportEnv()
+
+@app.get("/")
+def read_root():
+    return {"message": "Welcome to OpenEnv Customer Support API"}
+
+@app.get("/reset", response_model=Observation)
+def reset_env():
+    """Reset the environment and yield the initial observation."""
+    return env_instance.reset()
+
+@app.post("/step")
+def step_env(action: Action):
+    """Submit an action schema to process the environment workflow."""
+    if env_instance.current_state is None:
+        raise HTTPException(status_code=400, detail="Environment is not initialized. Please call /reset first.")
+        
+    obs, reward, done, info = env_instance.step(action)
+    return {
+        "observation": obs.dict(),
+        "reward": reward.dict(),
+        "done": done,
+        "info": info
+    }
+
+@app.get("/state", response_model=Observation)
+def get_state():
+    """Retrieve the current deterministic state of the environment."""
+    if env_instance.current_state is None:
+        raise HTTPException(status_code=400, detail="Environment is not initialized. Please call /reset first.")
+    return env_instance.state()
+
+@app.get("/tasks")
+def get_tasks():
+    """Retrieve all available tasks mapped in the environment."""
+    return {"tasks": get_all_tasks()}
+
+@app.get("/grader")
+def run_grader(task_id: str = Query(..., description="The matching task ID to score against (e.g. 'task_easy_1')")):
+    """Grade the current state of the ticket interaction strictly using the deterministic grader."""
+    if env_instance.current_state is None:
+        raise HTTPException(status_code=400, detail="Environment is not initialized. Please call /reset first.")
+        
+    # Map task ID to its logical difficulty tier
+    tasks = get_all_tasks()
+    task_diff = "EASY"
+    for t in tasks:
+        if t["id"] == task_id:
+            task_diff = t["difficulty"]
+            break
+            
+    # Mock history extraction mapped to grader logic expecting the final state
+    mock_history = [{"state": env_instance.current_state}]
+    
+    score = score_episode(task_diff, mock_history, env_instance.ground_truth)
+    return {"task_id": task_id, "score": score}
+
+@app.get("/baseline")
+def run_baseline():
+    """Execute a hardcoded 'perfect' baseline workflow on the current scenario to trace rewards."""
+    if env_instance.current_state is None:
+        env_instance.reset()
+        
+    gt = env_instance.ground_truth
+    
+    baseline_sequence = [
+        {"action_type": "classify_ticket", "payload": {"classification": gt["expected_classification"]}},
+        {"action_type": "assign_priority", "payload": {"priority": gt["expected_priority"]}},
+        {"action_type": "generate_response", "payload": {"response": "I am so sorry for the inconvenience. That is completely fixed now."}},
+        {"action_type": "resolve", "payload": {}}
+    ]
+    
+    trace_results = []
+    
+    for step_logic in baseline_sequence:
+        action = Action(**step_logic)
+        obs, reward, done, info = env_instance.step(action)
+        trace_results.append({
+            "action": step_logic,
+            "reward_earned": reward.value,
+            "done": done
+        })
+        if done:
+            break
+            
+    return {
+        "message": "Baseline ideal sequence successfully executed against ground truth.",
+        "trace": trace_results,
+        "final_state": env_instance.current_state
+    }

app/models.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel
+from typing import Any, Optional, Dict
+
+class Action(BaseModel):
+    action_type: str
+    payload: Dict[str, Any]
+
+class Observation(BaseModel):
+    state: Dict[str, Any]
+    info: Optional[Dict[str, Any]] = None
+
+class Reward(BaseModel):
+    value: float
+    is_terminal: bool

app/tasks.py

@@ -0,0 +1,23 @@
+from typing import List, Dict
+
+TASKS = [
+    {
+        "id": "task_easy_1",
+        "difficulty": "EASY",
+        "objective": "Only classify the issue correctly. You do not need to assign priority or resolve the ticket.",
+    },
+    {
+        "id": "task_medium_1",
+        "difficulty": "MEDIUM",
+        "objective": "Classify the ticket issue correctly and generate an appropriate response. If the customer is angry, ensure the response includes empathy (e.g., 'sorry').",
+    },
+    {
+        "id": "task_hard_1",
+        "difficulty": "HARD",
+        "objective": "Complete the full support workflow: 1. Correctly classify the issue, 2. Accurately assign priority, 3. Generate a correct, empathetic response, and 4. Officially resolve (close) the ticket.",
+    }
+]
+
+def get_all_tasks() -> List[Dict[str, str]]:
+    """Retrieve list of all registered tasks."""
+    return TASKS

frontend

@@ -0,0 +1 @@
+Subproject commit db65d9cb06efad6a3c9a5b6c0f0d3d38822bcf0f

inference.py

@@ -0,0 +1,110 @@
+import os
+import json
+import argparse
+from typing import Any
+from huggingface_hub import InferenceClient
+from app.env import CustomerSupportEnv
+from app.models import Action
+
+def evaluate_llm(task_id: str):
+    """Deterministically evaluate a Hugging Face LLM agent against the support environment."""
+    # Strict dynamic config parsing against Hugging Face requirements
+    model_name = os.environ.get("MODEL_NAME", "meta-llama/Meta-Llama-3-8B-Instruct")
+    hf_token = os.environ.get("HF_TOKEN", "")
+    
+    # Initialize Strict standard OpenEnv tracking log
+    print(f"[START] task={task_id} env=customer-support-env model={model_name}")
+
+    if not hf_token:
+        print("Warning: HF_TOKEN is explicitly empty. Hugging Face Inference may fail or rate limit.")
+
+    # Execute via Hugging Face Hub natively mapped to their architecture
+    client = InferenceClient(
+        model=model_name,
+        token=hf_token
+    )
+
+    env = CustomerSupportEnv()
+    obs = env.reset()
+    
+    rewards_history = []
+    
+    # Inject formal logic constraints prompting reliable JSON interactions
+    system_prompt = """You are a highly structured AI customer support agent resolving a ticket pipeline.
+Available actions list:
+1. classify_ticket (payload format: {"classification": "refund" | "general_inquiry" | "login_issue" | "feedback"})
+2. assign_priority (payload format: {"priority": "low" | "medium" | "high"})
+3. generate_response (payload format: {"response": "<text>"})
+4. escalate (payload format: {})
+5. resolve (payload format: {})
+
+You MUST return ONLY a fully valid JSON format mapping this dict schema:
+{
+  "action_type": "<action_name>",
+  "payload": { ... }
+}"""
+
+    done = False
+    step_count = 0
+    conversation_messages = [
+        {"role": "system", "content": system_prompt}
+    ]
+
+    # Interaction Loop
+    while not done and step_count < env.max_steps:
+        step_count += 1
+        
+        obs_stringified = json.dumps(obs.dict()["state"])
+        conversation_messages.append({"role": "user", "content": f"Current Ticket State: {obs_stringified}\nProvide your next action strictly in JSON:"})
+        
+        error_msg = ""
+        action_type = "unknown"
+        reward_val = 0.0
+        
+        try:
+            # Deterministic, reproducible call explicitly leveraging HF formats
+            response = client.chat_completion(
+                messages=conversation_messages,
+                temperature=0.01, # Hugging Face often crashes on explicitly 0.0 depending on the endpoint model deployed
+                max_tokens=256,
+                response_format={"type": "json"} if hasattr(client, "chat_completion") else None 
+                # Note: Not all HF hosted models support automatic JSON constraints, but instructions prompt for it natively.
+            )
+            
+            action_text = response.choices[0].message.content
+            action_data = json.loads(action_text)
+            
+            action_type = action_data.get("action_type", "unknown")
+            action = Action(**action_data)
+            
+            # Step the mathematical environment
+            obs, reward, done, info = env.step(action)
+            reward_val = reward.value
+            
+            # Provide reflection feedback to AI
+            conversation_messages.append({"role": "assistant", "content": action_text})
+            conversation_messages.append({"role": "system", "content": f"Action result mapping: Reward={reward_val}, Done={done}, Info={json.dumps(info)}"})
+            
+        except Exception as e:
+            error_msg = str(e).replace("\n", " ").strip()
+            reward_val = -1.0
+            done = True
+            
+        rewards_history.append(reward_val)
+        
+        # Output Explicit formatted log
+        done_str = "true" if done else "false"
+        print(f"[STEP] step={step_count} action={action_type} reward={reward_val:.2f} done={done_str} error={error_msg}")
+
+    # Output Explicit formatted termination log
+    # True metric determined by pipeline resolution logic
+    success_str = "true" if (env.current_state and env.current_state.get("status") == "closed" and rewards_history and rewards_history[-1] > 0) else "false"
+    r_mapped = ",".join(f"{r:.2f}" for r in rewards_history)
+    print(f"[END] success={success_str} steps={step_count} rewards={r_mapped}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--task", type=str, default="task_hard_1", help="Task ID sequence to execute logic against.")
+    args = parser.parse_args()
+    
+    evaluate_llm(args.task)

openenv.yaml

@@ -0,0 +1,8 @@
+name: "customer-support-env"
+version: "1.0.0"
+description: "Customer Support Environment for OpenEnv"
+
+environment:
+  type: "custom"
+  package: "app.env"
+  class: "CustomerSupportEnv"

push_to_hf.py

@@ -0,0 +1,41 @@
+import os
+from huggingface_hub import login, upload_folder
+
+def main():
+    print("Welcome to the Hugging Face Upload Hook!")
+    
+    # Check if we already have the token in the environment to avoid blocking if possible
+    hf_token = os.environ.get("HF_TOKEN")
+    
+    if hf_token:
+        print("HF_TOKEN detected. Logging in securely...")
+        login(token=hf_token)
+    else:
+        print("No HF_TOKEN found in environment variables.")
+        print("Please securely provide your Hugging Face Access Token when prompted:")
+        login()
+        
+    repo_target = "vivekvish2004/openenv-customer-support"
+    print(f"\nPushing current workspace files to Hugging Face Model Repository -> {repo_target}")
+    
+    # Push the model files
+    upload_folder(
+        folder_path=".", 
+        repo_id=repo_target, 
+        repo_type="model",
+        ignore_patterns=[
+            "frontend/node_modules/**", 
+            "frontend/.next/**", 
+            "__pycache__/**", 
+            ".git/**", 
+            ".venv/**", 
+            "venv/**", 
+            "env/**", 
+            ".DS_Store"
+        ] # Keeps the upload lightweight preventing the 504 Timeout
+    )
+    
+    print("\n✅ Successfully uploaded OpenEnv Customer Support to Hugging Face!")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,4 @@
+fastapi
+uvicorn
+pydantic
+openai