Fix: use gr.ChatInterface instead of gr.Blocks+Chatbot to avoid Gradio 4.44 type bug

app.py

@@ -8,13 +8,13 @@ import git as gitlib
 WORKSPACE = Path("/workspace")
 WORKSPACE.mkdir(exist_ok=True)
 
-# ---------- Model load (CPU friendly) ----------
+# ---------- Model load ----------
 MODEL_REPO = "Qwen/Qwen2.5-Coder-1.5B-Instruct-GGUF"
 MODEL_FILE = "qwen2.5-coder-1.5b-instruct-q4_k_m.gguf"
 
-print("⏬ Downloading model ...")
+print("Downloading model ...")
 model_path = hf_hub_download(repo_id=MODEL_REPO, filename=MODEL_FILE)
-print("✅ Loading llama.cpp ...")
+print("Loading llama.cpp ...")
 llm = Llama(
     model_path=model_path,
     n_ctx=4096,
@@ -24,85 +24,74 @@ llm = Llama(
 )
 
 # ---------- Tools ----------
-def _safe(p: str) -> Path:
+def _safe(p):
     path = (WORKSPACE / p).resolve()
     if WORKSPACE.resolve() not in path.parents and path != WORKSPACE.resolve():
         raise ValueError("Path escapes workspace")
     return path
 
-def read_file(path: str) -> str:
-    return _safe(path).read_text(encoding="utf-8", errors="replace")
+def read_file(path): return _safe(path).read_text(encoding="utf-8", errors="replace")
 
-def write_file(path: str, content: str) -> str:
+def write_file(path, content):
     p = _safe(path); p.parent.mkdir(parents=True, exist_ok=True)
     p.write_text(content, encoding="utf-8")
     return f"wrote {len(content)} bytes -> {path}"
 
-def edit_file(path: str, find: str, replace: str) -> str:
+def edit_file(path, find, replace):
     p = _safe(path); txt = p.read_text(encoding="utf-8")
     if find not in txt: return "pattern not found"
-    new = txt.replace(find, replace)
-    p.write_text(new, encoding="utf-8")
+    new = txt.replace(find, replace); p.write_text(new, encoding="utf-8")
     return f"replaced {txt.count(find)} occurrence(s) in {path}"
 
-def delete_file(path: str) -> str:
+def delete_file(path):
     p = _safe(path)
     if p.is_dir(): shutil.rmtree(p)
     else: p.unlink()
     return f"deleted {path}"
 
-def search_files(pattern: str, root: str = ".") -> str:
+def search_files(pattern, root="."):
     base = _safe(root)
     hits = [str(Path(x).relative_to(WORKSPACE)) for x in glob.glob(f"{base}/**/{pattern}", recursive=True)]
     return json.dumps(hits[:200])
 
-def git_clone(url: str, dest: str = "") -> str:
+def git_clone(url, dest=""):
     name = dest or url.rstrip("/").split("/")[-1].replace(".git", "")
     target = _safe(name)
     if target.exists(): return f"{name} already exists"
     gitlib.Repo.clone_from(url, target)
     return f"cloned -> {name}"
 
-def git_pull(repo: str) -> str:
-    r = gitlib.Repo(_safe(repo)); r.remotes.origin.pull()
-    return "pulled"
+def git_pull(repo):
+    r = gitlib.Repo(_safe(repo)); r.remotes.origin.pull(); return "pulled"
 
-def git_push(repo: str, message: str = "update", token: str = "") -> str:
+def git_push(repo, message="update", token=""):
     r = gitlib.Repo(_safe(repo))
     r.git.add(A=True); r.index.commit(message)
     if token:
         url = r.remotes.origin.url.replace("https://", f"https://x-access-token:{token}@")
         r.remotes.origin.set_url(url)
-    r.remotes.origin.push()
-    return "pushed"
+    r.remotes.origin.push(); return "pushed"
 
 def _run(cmd, cwd):
     proc = subprocess.run(cmd, cwd=cwd, shell=True, capture_output=True, text=True, timeout=1800)
     return f"[exit {proc.returncode}]\n{proc.stdout[-4000:]}\n{proc.stderr[-2000:]}"
 
-def gradle_build(repo: str, task: str = "assembleDebug") -> str:
-    cwd = _safe(repo)
-    wrapper = cwd / "gradlew"
+def gradle_build(repo, task="assembleDebug"):
+    cwd = _safe(repo); wrapper = cwd / "gradlew"
     if wrapper.exists():
-        os.chmod(wrapper, 0o755)
-        return _run(f"./gradlew {task} --no-daemon", cwd)
+        os.chmod(wrapper, 0o755); return _run(f"./gradlew {task} --no-daemon", cwd)
     return _run(f"gradle {task} --no-daemon", cwd)
 
-def build_apk(repo: str, variant: str = "debug") -> str:
+def build_apk(repo, variant="debug"):
     task = f"assemble{variant.capitalize()}"
     log = gradle_build(repo, task)
     apks = glob.glob(f"{_safe(repo)}/**/*.apk", recursive=True)
     return log + "\nAPKs:\n" + "\n".join(apks)
 
-def upload_artifact(path: str, repo_id: str, token: str, path_in_repo: str = "") -> str:
-    api = HfApi(token=token)
-    p = _safe(path)
-    api.upload_file(
-        path_or_fileobj=str(p),
-        path_in_repo=path_in_repo or p.name,
-        repo_id=repo_id,
-        repo_type="model",
-    )
+def upload_artifact(path, repo_id, token, path_in_repo=""):
+    api = HfApi(token=token); p = _safe(path)
+    api.upload_file(path_or_fileobj=str(p), path_in_repo=path_in_repo or p.name,
+                    repo_id=repo_id, repo_type="model")
     return f"uploaded {p.name} -> {repo_id}"
 
 TOOLS = {
@@ -114,66 +103,44 @@ TOOLS = {
 }
 
 TOOL_SPEC = """
-Available tools (call by emitting a single JSON block: ```tool\n{"name":"...","args":{...}}\n```):
-- read_file(path)
-- write_file(path, content)
-- edit_file(path, find, replace)
-- delete_file(path)
-- search_files(pattern, root=".")
-- git_clone(url, dest="")
-- git_pull(repo)
-- git_push(repo, message="update", token="")
-- gradle_build(repo, task="assembleDebug")
-- build_apk(repo, variant="debug")
-- upload_artifact(path, repo_id, token, path_in_repo="")
-After tool result, continue. End with plain answer when done.
+Tools (emit JSON block: ```tool\n{"name":"...","args":{...}}\n```):
+read_file, write_file, edit_file, delete_file, search_files,
+git_clone, git_pull, git_push, gradle_build, build_apk, upload_artifact
 """
 
 SYSTEM = "You are an Android build agent. Use tools to clone, edit, build APKs, and upload artifacts. " + TOOL_SPEC
-
 TOOL_RE = re.compile(r"```tool\s*(\{.*?\})\s*```", re.S)
 
-def run_agent(user_msg, history, max_steps=6):
+def chat_fn(message, history):
     msgs = [{"role": "system", "content": SYSTEM}]
-    for item in history:
-        if isinstance(item, (list, tuple)) and len(item) == 2:
-            u, a = item
-            if u:
-                msgs.append({"role": "user", "content": str(u)})
-            if a:
-                msgs.append({"role": "assistant", "content": str(a)})
-    msgs.append({"role": "user", "content": user_msg})
+    for h in history:
+        msgs.append({"role": "user", "content": h[0]})
+        msgs.append({"role": "assistant", "content": h[1]})
+    msgs.append({"role": "user", "content": message})
 
     transcript = ""
-    for _ in range(max_steps):
+    for _ in range(6):
         out = llm.create_chat_completion(messages=msgs, temperature=0.2, max_tokens=800)
         reply = out["choices"][0]["message"]["content"]
         transcript += reply + "\n"
         m = TOOL_RE.search(reply)
         if not m:
-            return transcript
+            return transcript.strip()
         try:
             call = json.loads(m.group(1))
-            fn = TOOLS[call["name"]]
-            result = fn(**call.get("args", {}))
+            result = TOOLS[call["name"]](**call.get("args", {}))
         except Exception as e:
-            result = f"ERROR: {e}\n{traceback.format_exc()[-500:]}"
+            result = f"ERROR: {e}\n{traceback.format_exc()[-300:]}"
         msgs.append({"role": "assistant", "content": reply})
         msgs.append({"role": "user", "content": f"tool_result:\n{result}"})
         transcript += f"\n[tool result]\n{result}\n"
-    return transcript
-
-with gr.Blocks(title="Android Build Agent") as demo:
-    gr.Markdown("## 🤖 Android Build Agent (Qwen2.5-Coder + Gradle + SDK)")
-    chat = gr.Chatbot(height=500, type="tuples")
-    box = gr.Textbox(placeholder="e.g. clone https://github.com/.../MyApp and build debug APK")
-    state = gr.State([])
+    return transcript.strip()
 
-    def respond(msg, hist):
-        ans = run_agent(msg, hist)
-        hist = hist + [(msg, ans)]
-        return "", hist, hist
-
-    box.submit(respond, [box, state], [box, chat, state])
+demo = gr.ChatInterface(
+    fn=chat_fn,
+    title="Android Build Agent",
+    description="Qwen2.5-Coder + Gradle + Android SDK",
+    examples=["Hello! What can you do?"],
+)
 
-demo.queue().launch(server_name="0.0.0.0", server_port=7860, share=False)
+demo.launch(server_name="0.0.0.0", server_port=7860)