lib!!!

app.py

@@ -0,0 +1,52 @@
+import random
+
+
+class WordleEnv:
+    """
+    Demonstration env. Not a full game; 4-letter variant for brevity.
+
+    Observations are emoji strings; actions are 4-letter lowercase words.
+    Reward is 1.0 on success, else 0.0. Terminal on success or after 6 guesses.
+    """
+
+    dictionary = {"word", "wood", "ward", "sore", "bore", "bake", "bake", "bake", "earn"}
+
+    def __init__(self, max_guesses: int = 6) -> None:
+        self._max = max_guesses
+
+    def reset(self) -> str:
+        self._secret = random.choice(list(self.dictionary))
+        self._n = 0
+        self._obs = "⬜" * 4
+        return self._obs
+
+    def step(self, action: str) -> tuple[str, float, bool]:
+        guess: str = str(action)
+        guess = guess.strip().lower()
+
+        if len(guess) != 4 or not guess.isalpha():
+            raise ValueError("Action must be a 4-letter lowercase word.")
+
+        if self._n >= self._max:
+            raise RuntimeError("Episode is done. Call reset() to start a new episode.")
+
+        self._n += 1
+        secret = self._secret
+        feedback: list[str] = []
+        for i, ch in enumerate(guess):
+            if ch == secret[i]:
+                feedback.append("🟩")
+            elif ch in secret:
+                feedback.append("🟨")
+            else:
+                feedback.append("⬜")
+        self._obs = "".join(feedback)
+        done = guess == secret or self._n >= self._max
+        reward = 1.0 if guess == secret else 0.0
+        return self._obs, reward, done
+
+
+from my_lib import get_demo
+
+demo = get_demo(WordleEnv)
+demo.launch(mcp_server=True)

my_lib.py

@@ -0,0 +1,59 @@
+import inspect
+import uuid
+from functools import wraps
+
+import gradio as gr
+
+
+def bind_method_to_session(method, registry: dict):
+    sig = inspect.signature(method)
+    params = list(sig.parameters.values())
+
+    @wraps(method)
+    def wrapper(session_id: str, *args, **kwargs):
+        instance = registry.get(session_id)
+        if instance is None:
+            raise ValueError(f"Invalid session_id: {session_id}")
+        m = getattr(instance, method.__func__.__name__)
+        return m(*args, **kwargs)
+
+    # --- update __annotations__ ---
+    wrapper.__annotations__ = method.__annotations__.copy()
+    wrapper.__annotations__["session_id"] = str
+
+    # --- build signature ---
+    new_params = (
+        inspect.Parameter(
+            "session_id",
+            kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
+            annotation=str,
+        ),
+        *params,
+    )
+    wrapper.__signature__ = inspect.Signature(
+        parameters=new_params,
+        return_annotation=sig.return_annotation,
+    )
+
+    return wrapper
+
+
+def get_demo(env_cls: type) -> gr.Blocks:
+    sessions = {}  # just a dict now
+
+    def init_env() -> str:
+        session_id = str(uuid.uuid4())
+        env = env_cls()
+        sessions[session_id] = env
+        return session_id
+
+    # Bind methods to session dict
+    reset_api = bind_method_to_session(env_cls().reset, sessions)
+    step_api = bind_method_to_session(env_cls().step, sessions)
+
+    with gr.Blocks() as demo:
+        gr.api(init_env, api_name="init")
+        gr.api(reset_api, api_name="reset")
+        gr.api(step_api, api_name="step")
+
+    return demo