Upload folder using huggingface_hub

README.md

@@ -80,22 +80,22 @@ class TokenOptimiserState(State):
 
 ## 📋 Tasks
 
-### 🟢 Easy — Verbosity Reduction
-**Original:** `"Can you please explain in a very detailed manner what machine learning is and how it works step by step?"`  
-**Goal:** Strip filler words, compress to core query  
-**Expected optimized:** `"Explain machine learning briefly."`  
-**Max output:** 50 tokens
-
-### 🟡 Medium — Format Constraint Addition
-**Original:** `"I need a comprehensive analysis of the renewable energy market trends over the past decade, including solar, wind, and hydroelectric power growth rates..."`  
-**Goal:** Compress input AND add explicit output format constraints  
-**Expected optimized:** `"Summarize 2013-2023 renewable energy trends: solar, wind, hydro. In 5 bullet points."`  
-**Max output:** 100 tokens
-
-### 🔴 Hard — Multi-Intent Structured Output
-**Original:** 82-word complex data science analysis request with 5 sub-tasks  
-**Goal:** Minimize total tokens (input + output) while producing structured JSON with all 5 required keys  
-**Expected optimized:** Compressed prompt specifying `JSON with keys: top_categories, growth_regions, responsive_segments, budget_allocation, risks_watch`  
+### 🟢 Easy — Redundancy Stripping
+**Original:** `"Could you possibly help me understand, if it's not too much trouble, what the word 'photosynthesis' means? I would really appreciate it if you could explain it to me in simple terms that are easy to understand."`  
+**Goal:** Strip politeness filler and redundancy to a single direct question without formatting  
+**Expected optimized:** `"What does photosynthesis mean? Be brief."`  
+**Max output:** 30 tokens
+
+### 🟡 Medium — Constraint Injection
+**Original:** `"I'm looking for information about the main differences between Python and JavaScript programming languages. Could you give me a thorough breakdown covering things like typing, use cases, performance, syntax style, and ecosystem so I can decide which one to learn first?"`  
+**Goal:** Compress input AND inject format + exactly 5 bullet point counts into prompt  
+**Expected optimized:** `"Compare Python and JavaScript (typing, use cases, performance, syntax, ecosystem) in exactly 5 bullet points."`  
+**Max output:** 120 tokens
+
+### 🔴 Hard — Multi-Key JSON Extraction
+**Original:** `"We need you to analyze our e-commerce platform data and provide strategic insights. Specifically: first identify which product categories are performing best by revenue, second tell us which geographic regions show the most growth potential, third identify which customer segments respond best to promotions, fourth suggest how we should allocate our Q3 marketing budget across channels, and fifth flag any market risks we should be watching. Please be thorough in your analysis and provide detailed reasoning for each point."`  
+**Goal:** Compress 82-word multi-intent prompt and force structured JSON output with 5 exact required keys  
+**Expected optimized:** `"Analyze e-commerce data based on revenue, growth regions, responsive segments, Q3 budget, and market risks. Output strictly as JSON with keys: top_categories, growth_regions, responsive_segments, budget_allocation, risks_watch."`  
 **Max output:** 200 tokens
 
 ---

inference.py

@@ -15,6 +15,7 @@ Environment variables required:
 """
 
 import asyncio
+import logging
 import os
 import textwrap
 from typing import List, Optional
@@ -27,6 +28,14 @@ except Exception:  # pragma: no cover
 
 from token_optimiser import TokenOptimiserEnv, TokenOptimiserAction
 
+logger = logging.getLogger("TokenOptimiserFrontend")
+logger.setLevel(logging.INFO)
+if not logger.handlers:
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter('\033[96m%(asctime)s\033[0m | \033[93m%(levelname)-7s\033[0m | \033[1mCLIENT\033[0m | %(message)s', datefmt='%H:%M:%S')
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+
 # ---------------------------------------------------------------------------
 # Configuration
 # ---------------------------------------------------------------------------
@@ -151,7 +160,7 @@ def get_optimized_prompt(
         result = (completion.choices[0].message.content or "").strip()
         return result if result else "Explain briefly."
     except Exception as exc:
-        print(f"[DEBUG] LLM call failed: {exc}", flush=True)
+        logger.warning(f"LLM call failed, falling back to basic rule compression: {exc}")
         return _rule_based_compress(original_prompt, step)
 
 
@@ -210,11 +219,8 @@ async def run_episode(llm: OpenAI) -> None:
         env_state = await env.state()
         original_prompt: str = env_state.original_prompt or "Explain machine learning briefly."
 
-        print(
-            f"[DEBUG] Task difficulty={env_state.task_difficulty} | "
-            f"Original prompt ({len(original_prompt.split())} words): {original_prompt[:80]}...",
-            flush=True,
-        )
+        logger.info(f"Task connected. Difficulty: {env_state.task_difficulty.upper()}")
+        logger.info(f"Original prompt ({len(original_prompt.split())} words): {original_prompt[:80]}...")
 
         prev_reward = 0.0
         prev_response = ""
@@ -236,10 +242,7 @@ async def run_episode(llm: OpenAI) -> None:
                 reward = result.reward          # server puts reward at top-level, not inside obs
                 done = result.done or (step >= MAX_STEPS)
                 prev_response = obs.llm_response
-                print(
-                    f"[DEBUG] tokens in={obs.input_tokens} out={obs.output_tokens}",
-                    flush=True,
-                )
+                logger.info(f"Step {step} Tokens => Input: {obs.input_tokens}, Output: {obs.output_tokens}")
             except Exception as exc:
                 error_msg = str(exc)
                 done = True
@@ -263,7 +266,7 @@ async def run_episode(llm: OpenAI) -> None:
         success = score >= SUCCESS_THRESHOLD
 
     except Exception as exc:
-        print(f"[DEBUG] Episode error: {exc}", flush=True)
+        logger.error(f"Episode error aborted run: {exc}")
     finally:
         try:
             await env.close()
@@ -274,7 +277,7 @@ async def run_episode(llm: OpenAI) -> None:
 
 async def main() -> None:
     if not HF_TOKEN:
-        print("[ERROR] HF_TOKEN environment variable not set. Exiting.", flush=True)
+        logger.error("HF_TOKEN environment variable not set. Exiting.")
         return
 
     llm = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)

openenv.yaml

@@ -4,4 +4,7 @@ type: space
 runtime: fastapi
 app: server.app:app
 port: 8000
-
+tasks:
+  - redundancy_stripping (easy)
+  - constraint_injection (medium)
+  - multi_key_json_extraction (hard)

openenv_token_optimiser.egg-info/SOURCES.txt

@@ -1,4 +1,8 @@
 README.md
+__init__.py
+client.py
+inference.py
+models.py
 pyproject.toml
 ./__init__.py
 ./client.py

server/app.py

@@ -54,7 +54,7 @@ app = create_app(
 )
 
 
-def main() -> None:
+def main(host: str = "0.0.0.0", port: int = 8000):
     """
     Entry point for direct execution via uv run or python -m.
 
@@ -63,20 +63,23 @@ def main() -> None:
         uv run --project . server --port 8001
         python -m token_optimiser.server.app
 
+    Args:
+        host: Host address to bind to (default: "0.0.0.0")
+        port: Port number to listen on (default: 8000)
+
     For production deployments, consider using uvicorn directly with
     multiple workers:
         uvicorn token_optimiser.server.app:app --workers 4
     """
-    import argparse
     import uvicorn
 
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--host", type=str, default="0.0.0.0")
-    parser.add_argument("--port", type=int, default=8000)
-    args = parser.parse_args()
-
-    uvicorn.run(app, host=args.host, port=args.port)
+    uvicorn.run(app, host=host, port=port)
 
 
 if __name__ == "__main__":
-    main()
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--port", type=int, default=8000)
+    args = parser.parse_args()
+    main(port=args.port)

server/token_optimiser_environment.py

@@ -11,10 +11,22 @@ A sandboxed LLM interaction environment where an AI agent optimizes both input p
 and expected output responses to minimize total token usage while maintaining correctness.
 """
 
+import json
+import logging
 import os
 import random
+import re
 from uuid import uuid4
 
+logger = logging.getLogger("TokenOptimiserBackend")
+logger.setLevel(logging.INFO)
+if not logger.handlers:
+    handler = logging.StreamHandler()
+    # Add clear ANSI color prefixes for visibility in backend terminal
+    formatter = logging.Formatter('\033[94m%(asctime)s\033[0m | \033[92m%(levelname)-7s\033[0m | \033[1m%(message)s\033[0m', datefmt='%H:%M:%S')
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+
 try:
     from openai import OpenAI
 except ImportError:
@@ -62,29 +74,30 @@ class TokenOptimiserEnvironment(Environment):
             # EASY TASK
             {
                 "difficulty": "easy",
-                "prompt": "Can you please explain in a very detailed manner what machine learning is and how it works step by step?",
-                "expected_format": "brief explanation",
-                "reference_response": "Machine learning is a subset of AI that enables computers to learn from data without explicit programming. It works by identifying patterns in training data to make predictions or decisions on new data.",
-                "max_output_tokens": 50,
-                "description": "Reduce verbosity while preserving core concept"
+                "prompt": "Could you possibly help me understand, if it's not too much trouble, what the word 'photosynthesis' means? I would really appreciate it if you could explain it to me in simple terms that are easy to understand.",
+                "expected_format": "plain_brief",
+                "reference_response": "Photosynthesis is how plants convert sunlight into food using CO2 and water.",
+                "max_output_tokens": 30,
+                "description": "Strip politeness filler and redundancy to a single direct question"
             },
             # MEDIUM TASK
             {
                 "difficulty": "medium",
-                "prompt": "I need a comprehensive analysis of the renewable energy market trends over the past decade, including solar, wind, and hydroelectric power growth rates, investment patterns, technological advancements, and policy impacts across different regions globally.",
-                "expected_format": "5 bullet points summarizing key trends",
-                "reference_response": "• Solar power capacity grew 22% annually avg.  • Wind energy investments reached $140B in 2020  • Hydroelectric remains largest renewable source  • Battery storage tech advancing rapidly  • Policy incentives driving global adoption",
-                "max_output_tokens": 100,
-                "description": "Compress input + specify bullet point format + length limit"
+                "prompt": "I'm looking for information about the main differences between Python and JavaScript programming languages. Could you give me a thorough breakdown covering things like typing, use cases, performance, syntax style, and ecosystem so I can decide which one to learn first?",
+                "expected_format": "bullet_5",
+                "reference_response": "• Python: dynamic typing, data/ML focus\n• JS: dynamic typing, web/frontend focus\n• Performance: JS V8 faster for runtime\n• Syntax: Python readable, JS C-like\n• Ecosystem: Python pip/sci libs, JS npm/frameworks",
+                "max_output_tokens": 120,
+                "description": "Compress input AND inject format + count constraint into prompt"
             },
             # HARD TASK
             {
                 "difficulty": "hard",
-                "prompt": "As a senior data scientist, I need you to analyze our Q3 sales performance dataset and provide actionable insights. The dataset contains: customer demographics, purchase history, product categories, regional sales data, marketing campaign ROI, seasonal trends, and competitor analysis. Please identify: 1) Our top 3 performing product categories and why, 2) Geographic regions with highest growth potential, 3) Customer segments most responsive to our email campaigns, 4) Optimal marketing budget allocation for Q4, and 5) Risks to watch based on economic indicators.",
-                "expected_format": "JSON with 5 keys: top_categories, growth_regions, responsive_segments, budget_allocation, risks_watch",
-                "reference_response": '{"top_categories": ["electronics", "software", "home_goods"], "growth_regions": ["SE Asia", "Latin America", "Africa"], "responsive_segments": ["young_professionals", "tech_enthusiasts"], "budget_allocation": {"email": 0.3, "social": 0.25, "search": 0.2, "tv": 0.15, "other": 0.1}, "risks_watch": ["inflation", "supply_chain", "labor_shortage"]}',
+                "prompt": "We need you to analyze our e-commerce platform data and provide strategic insights. Specifically: first identify which product categories are performing best by revenue, second tell us which geographic regions show the most growth potential, third identify which customer segments respond best to promotions, fourth suggest how we should allocate our Q3 marketing budget across channels, and fifth flag any market risks we should be watching. Please be thorough in your analysis and provide detailed reasoning for each point.",
+                "expected_format": "json_5keys",
+                "reference_response": '{"top_categories":"...","growth_regions":"...","responsive_segments":"...","budget_allocation":"...","risks_watch":"..."}',
+                "required_json_keys": ["top_categories", "growth_regions", "responsive_segments", "budget_allocation", "risks_watch"],
                 "max_output_tokens": 200,
-                "description": "Multi-intent optimization: compress complex request + specify JSON format + accuracy + length constraints"
+                "description": "Compress 82-word multi-intent prompt and force structured JSON output with 5 exact keys"
             }
         ]
 
@@ -106,6 +119,11 @@ class TokenOptimiserEnvironment(Environment):
         )
         self._reset_count += 1
 
+        logger.info(f"------ ENVIRONMENT RESET ------")
+        logger.info(f"Loaded Task: [{self._current_task['difficulty'].upper()}] Index: {self._state.task_index}")
+        logger.info(f"Requirements: Format='{self._current_task['expected_format']}', Max Tokens={self._current_task['max_output_tokens']}")
+        logger.info(f"-------------------------------")
+
         return TokenOptimiserObservation(
             llm_response="",
             input_tokens=0,
@@ -143,12 +161,24 @@ class TokenOptimiserEnvironment(Environment):
         # 4. Format compliance (0.0-0.2)
         expected_fmt = self._current_task["expected_format"]
         format_score = 0.0
-        if "bullet" in expected_fmt and any(c in llm_response for c in ("•", "*", "-", "\n")):
-            format_score = 0.2
-        elif "json" in expected_fmt.lower() and "{" in llm_response and "}" in llm_response:
-            format_score = 0.2
-        elif "brief" in expected_fmt and len(llm_response.split()) < 30:
-            format_score = 0.2
+        if expected_fmt == "bullet_5":
+            bullet_count = llm_response.count('•')
+            if bullet_count >= 5:
+                format_score = 0.2
+            elif 3 <= bullet_count <= 4:
+                format_score = 0.1
+        elif expected_fmt == "json_5keys":
+            try:
+                parsed = json.loads(llm_response.strip())
+                keys_present = sum(1 for k in self._current_task["required_json_keys"] if k in parsed)
+                format_score = 0.04 * keys_present
+            except json.JSONDecodeError:
+                format_score = 0.0
+        elif expected_fmt == "plain_brief":
+            sentences = len([s for s in re.split(r'[.!?]+', llm_response) if s.strip()])
+            has_no_bullets = not any(c in llm_response for c in ("•", "-", "*"))
+            if sentences <= 2 and has_no_bullets:
+                format_score = 0.2
 
         # 5. Length penalty if output way too long
         max_out = self._current_task["max_output_tokens"]
@@ -163,10 +193,11 @@ class TokenOptimiserEnvironment(Environment):
         )
         reward = max(0.0, min(1.0, reward))
 
-        print(
-            f"[ENV] tok_eff={token_efficiency:.2f} semantic={semantic_score:.2f} "
-            f"fmt={format_score:.2f} => reward={reward:.2f}",
-            flush=True,
+        logger.info(f"[STEP {self._state.step_count}] Optimized Prompt Length: {len(optimized_prompt.split())} words")
+        logger.info(f"  └─ Tokens => In: {int(input_tokens)}, Out: {int(output_tokens)}")
+        logger.info(
+            f"  └─ Reward => Tok_Eff:{token_efficiency:.2f} | Semantic:{semantic_score*0.3:.2f} | "
+            f"Fmt:{format_score:.2f} | Penalty:{length_penalty:.2f} || TOTAL: {reward:.3f}"
         )
 
         return TokenOptimiserObservation(
@@ -196,13 +227,14 @@ class TokenOptimiserEnvironment(Environment):
                     return text, in_tok, out_tok
                 except Exception as e:
                     if "429" in str(e) or "Too Many Requests" in str(e):
-                        print(f"[ENV] Rate limited, waiting 3s (attempt {attempt+1})...")
+                        logger.warning(f"Rate limited, waiting 3s (attempt {attempt+1})...")
                         time.sleep(3)
                     else:
-                        print(f"[ENV] LLM call failed: {e}")
+                        logger.error(f"LLM call failed: {e}")
                         break
 
         # Rule-based fallback
+        logger.debug("Falling back to rule-based simulation.")
         return self._fallback_simulate(prompt)
 
     def _fallback_simulate(self, prompt: str) -> tuple[str, int, int]:

validator_script.sh

@@ -0,0 +1,185 @@
+#!/usr/bin/env bash
+#
+# validate-submission.sh — OpenEnv Submission Validator
+#
+# Checks that your HF Space is live, Docker image builds, and openenv validate passes.
+#
+# Prerequisites:
+#   - Docker:       https://docs.docker.com/get-docker/
+#   - openenv-core: pip install openenv-core
+#   - curl (usually pre-installed)
+#
+# Run:
+#   curl -fsSL https://raw.githubusercontent.com/<owner>/<repo>/main/scripts/validate-submission.sh | bash -s -- <ping_url> [repo_dir]
+#
+#   Or download and run locally:
+#     chmod +x validate-submission.sh
+#     ./validate-submission.sh <ping_url> [repo_dir]
+#
+# Arguments:
+#   ping_url   Your HuggingFace Space URL (e.g. https://your-space.hf.space)
+#   repo_dir   Path to your repo (default: current directory)
+#
+# Examples:
+#   ./validate-submission.sh https://my-team.hf.space
+#   ./validate-submission.sh https://my-team.hf.space ./my-repo
+#
+
+set -uo pipefail
+
+DOCKER_BUILD_TIMEOUT=600
+if [ -t 1 ]; then
+  RED='\033[0;31m'
+  GREEN='\033[0;32m'
+  YELLOW='\033[1;33m'
+  BOLD='\033[1m'
+  NC='\033[0m'
+else
+  RED='' GREEN='' YELLOW='' BOLD='' NC=''
+fi
+
+run_with_timeout() {
+  local secs="$1"; shift
+  if command -v timeout &>/dev/null; then
+    timeout "$secs" "$@"
+  elif command -v gtimeout &>/dev/null; then
+    gtimeout "$secs" "$@"
+  else
+    "$@" &
+    local pid=$!
+    ( sleep "$secs" && kill "$pid" 2>/dev/null ) &
+    local watcher=$!
+    wait "$pid" 2>/dev/null
+    local rc=$?
+    kill "$watcher" 2>/dev/null
+    wait "$watcher" 2>/dev/null
+    return $rc
+  fi
+}
+
+portable_mktemp() {
+  local prefix="${1:-validate}"
+  mktemp "${TMPDIR:-/tmp}/${prefix}-XXXXXX" 2>/dev/null || mktemp
+}
+
+CLEANUP_FILES=()
+cleanup() { rm -f "${CLEANUP_FILES[@]+"${CLEANUP_FILES[@]}"}"; }
+trap cleanup EXIT
+
+PING_URL="${1:-}"
+REPO_DIR="${2:-.}"
+
+if [ -z "$PING_URL" ]; then
+  printf "Usage: %s <ping_url> [repo_dir]\n" "$0"
+  printf "\n"
+  printf "  ping_url   Your HuggingFace Space URL (e.g. https://your-space.hf.space)\n"
+  printf "  repo_dir   Path to your repo (default: current directory)\n"
+  exit 1
+fi
+
+if ! REPO_DIR="$(cd "$REPO_DIR" 2>/dev/null && pwd)"; then
+  printf "Error: directory '%s' not found\n" "${2:-.}"
+  exit 1
+fi
+PING_URL="${PING_URL%/}"
+export PING_URL
+PASS=0
+
+log()  { printf "[%s] %b\n" "$(date -u +%H:%M:%S)" "$*"; }
+pass() { log "${GREEN}PASSED${NC} -- $1"; PASS=$((PASS + 1)); }
+fail() { log "${RED}FAILED${NC} -- $1"; }
+hint() { printf "  ${YELLOW}Hint:${NC} %b\n" "$1"; }
+stop_at() {
+  printf "\n"
+  printf "${RED}${BOLD}Validation stopped at %s.${NC} Fix the above before continuing.\n" "$1"
+  exit 1
+}
+
+printf "\n"
+printf "${BOLD}========================================${NC}\n"
+printf "${BOLD}  OpenEnv Submission Validator${NC}\n"
+printf "${BOLD}========================================${NC}\n"
+log "Repo:     $REPO_DIR"
+log "Ping URL: $PING_URL"
+printf "\n"
+
+log "${BOLD}Step 1/3: Pinging HF Space${NC} ($PING_URL/reset) ..."
+
+CURL_OUTPUT=$(portable_mktemp "validate-curl")
+CLEANUP_FILES+=("$CURL_OUTPUT")
+HTTP_CODE=$(curl -s -o "$CURL_OUTPUT" -w "%{http_code}" -X POST \
+  -H "Content-Type: application/json" -d '{}' \
+  "$PING_URL/reset" --max-time 30 2>"$CURL_OUTPUT" || printf "000")
+
+if [ "$HTTP_CODE" = "200" ]; then
+  pass "HF Space is live and responds to /reset"
+elif [ "$HTTP_CODE" = "000" ]; then
+  fail "HF Space not reachable (connection failed or timed out)"
+  hint "Check your network connection and that the Space is running."
+  hint "Try: curl -s -o /dev/null -w '%%{http_code}' -X POST $PING_URL/reset"
+  stop_at "Step 1"
+else
+  fail "HF Space /reset returned HTTP $HTTP_CODE (expected 200)"
+  hint "Make sure your Space is running and the URL is correct."
+  hint "Try opening $PING_URL in your browser first."
+  stop_at "Step 1"
+fi
+
+log "${BOLD}Step 2/3: Running docker build${NC} ..."
+
+if ! command -v docker &>/dev/null; then
+  fail "docker command not found"
+  hint "Install Docker: https://docs.docker.com/get-docker/"
+  stop_at "Step 2"
+fi
+
+if [ -f "$REPO_DIR/Dockerfile" ]; then
+  DOCKER_CONTEXT="$REPO_DIR"
+elif [ -f "$REPO_DIR/server/Dockerfile" ]; then
+  DOCKER_CONTEXT="$REPO_DIR/server"
+else
+  fail "No Dockerfile found in repo root or server/ directory"
+  stop_at "Step 2"
+fi
+
+log "  Found Dockerfile in $DOCKER_CONTEXT"
+
+BUILD_OK=false
+BUILD_OUTPUT=$(run_with_timeout "$DOCKER_BUILD_TIMEOUT" docker build "$DOCKER_CONTEXT" 2>&1) && BUILD_OK=true
+
+if [ "$BUILD_OK" = true ]; then
+  pass "Docker build succeeded"
+else
+  fail "Docker build failed (timeout=${DOCKER_BUILD_TIMEOUT}s)"
+  printf "%s\n" "$BUILD_OUTPUT" | tail -20
+  stop_at "Step 2"
+fi
+
+log "${BOLD}Step 3/3: Running openenv validate${NC} ..."
+
+if ! command -v openenv &>/dev/null; then
+  fail "openenv command not found"
+  hint "Install it: pip install openenv-core"
+  stop_at "Step 3"
+fi
+
+VALIDATE_OK=false
+VALIDATE_OUTPUT=$(cd "$REPO_DIR" && openenv validate 2>&1) && VALIDATE_OK=true
+
+if [ "$VALIDATE_OK" = true ]; then
+  pass "openenv validate passed"
+  [ -n "$VALIDATE_OUTPUT" ] && log "  $VALIDATE_OUTPUT"
+else
+  fail "openenv validate failed"
+  printf "%s\n" "$VALIDATE_OUTPUT"
+  stop_at "Step 3"
+fi
+
+printf "\n"
+printf "${BOLD}========================================${NC}\n"
+printf "${GREEN}${BOLD}  All 3/3 checks passed!${NC}\n"
+printf "${GREEN}${BOLD}  Your submission is ready to submit.${NC}\n"
+printf "${BOLD}========================================${NC}\n"
+printf "\n"
+
+exit 0