abstractagent 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

abstractagent/scripts/lmstudio_tool_eval.py

@@ -0,0 +1,426 @@
+"""LMStudio tool-synergy evaluation harness (manual, real LLM).
+
+Runs a few deterministic scenarios against a real provider/model (e.g. LMStudio
+`qwen/qwen3-next-80b`) and prints a compact summary of tool usage patterns:
+- whether the model uses analyze_code/search_files before bounded reads
+- whether edits succeed without repeated identical retries
+- how often it reads whole files vs slices
+
+This is intentionally NOT a required CI test. It should be run manually.
+
+Usage:
+  ABSTRACTAGENT_TEST_PROVIDER=lmstudio \
+  ABSTRACTAGENT_TEST_MODEL=qwen/qwen3-next-80b \
+  ABSTRACTAGENT_TEST_BASE_URL=http://localhost:1234/v1 \
+  python -m abstractagent.scripts.lmstudio_tool_eval
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from datetime import datetime, timezone
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple
+
+
+def _llm_config() -> Tuple[str, str, Dict[str, Any]]:
+    provider = os.getenv("ABSTRACTAGENT_TEST_PROVIDER", "lmstudio")
+    model = os.getenv("ABSTRACTAGENT_TEST_MODEL", "qwen/qwen3-next-80b")
+    base_url = os.getenv("ABSTRACTAGENT_TEST_BASE_URL")
+
+    llm_kwargs: Dict[str, Any] = {"temperature": 0}
+    llm_kwargs["seed"] = 42
+    if base_url:
+        llm_kwargs["base_url"] = base_url
+    return provider, model, llm_kwargs
+
+
+@dataclass(frozen=True)
+class ToolCallEvent:
+    ts: str
+    name: str
+    arguments: Dict[str, Any]
+    success: Optional[bool]
+    error: Optional[str]
+
+
+def _iter_tool_calls(traces: Dict[str, Any]) -> List[ToolCallEvent]:
+    events: List[ToolCallEvent] = []
+    for _node_id, trace in (traces or {}).items():
+        steps = trace.get("steps") if isinstance(trace, dict) else None
+        if not isinstance(steps, list):
+            continue
+        for step in steps:
+            if not isinstance(step, dict):
+                continue
+            eff = step.get("effect")
+            if not isinstance(eff, dict):
+                continue
+            if eff.get("type") != "tool_calls":
+                continue
+            payload = eff.get("payload") if isinstance(eff.get("payload"), dict) else {}
+            tool_calls = payload.get("tool_calls")
+            if not isinstance(tool_calls, list):
+                continue
+            result = step.get("result") if isinstance(step.get("result"), dict) else {}
+            results = result.get("results") if isinstance(result.get("results"), list) else []
+
+            for idx, tc in enumerate(tool_calls):
+                if not isinstance(tc, dict):
+                    continue
+                name = str(tc.get("name") or "").strip()
+                if not name:
+                    continue
+                args = tc.get("arguments")
+                if not isinstance(args, dict):
+                    args = {}
+
+                success = None
+                error = None
+                if idx < len(results) and isinstance(results[idx], dict):
+                    success = results[idx].get("success")
+                    error = results[idx].get("error")
+                    if success is not None:
+                        success = bool(success)
+                    if error is not None:
+                        error = str(error)
+
+                events.append(
+                    ToolCallEvent(
+                        ts=str(step.get("ts") or ""),
+                        name=name,
+                        arguments=dict(args),
+                        success=success,
+                        error=error,
+                    )
+                )
+
+    events.sort(key=lambda e: e.ts)
+    return events
+
+
+def _json_key(value: Any) -> str:
+    try:
+        return json.dumps(value, sort_keys=True, ensure_ascii=False, default=str)
+    except Exception:
+        return str(value)
+
+
+def _summarize_tool_usage(events: List[ToolCallEvent]) -> Dict[str, Any]:
+    tool_counts: Dict[str, int] = {}
+    full_reads = 0
+    sliced_reads = 0
+    repeated_calls: Dict[str, int] = {}
+    edit_pattern_sizes: List[int] = []
+    failures: Dict[str, int] = {}
+
+    seen_call_keys: Dict[str, int] = {}
+
+    for e in events:
+        tool_counts[e.name] = tool_counts.get(e.name, 0) + 1
+        if e.success is False:
+            failures[e.name] = failures.get(e.name, 0) + 1
+
+        key = f"{e.name}:{_json_key(e.arguments)}"
+        seen_call_keys[key] = seen_call_keys.get(key, 0) + 1
+
+        if e.name == "read_file":
+            should_entire = e.arguments.get("should_read_entire_file", True)
+            start = (
+                e.arguments.get("start_line")
+                if e.arguments.get("start_line") is not None
+                else e.arguments.get("start_line_one_indexed", e.arguments.get("start", 1))
+            )
+            end = (
+                e.arguments.get("end_line")
+                if e.arguments.get("end_line") is not None
+                else e.arguments.get("end_line_one_indexed_inclusive", e.arguments.get("end"))
+            )
+            try:
+                start_i = int(start or 1)
+            except Exception:
+                start_i = 1
+
+            # If a range was requested (even via aliases), treat as a slice read.
+            if end is not None or start_i != 1 or bool(should_entire) is False:
+                sliced_reads += 1
+            else:
+                full_reads += 1
+
+        if e.name == "edit_file":
+            pattern = e.arguments.get("pattern")
+            if isinstance(pattern, str):
+                edit_pattern_sizes.append(len(pattern))
+
+    for k, v in seen_call_keys.items():
+        if v > 1:
+            repeated_calls[k] = v
+
+    return {
+        "tool_counts": dict(sorted(tool_counts.items(), key=lambda kv: (-kv[1], kv[0]))),
+        "failures": dict(sorted(failures.items(), key=lambda kv: (-kv[1], kv[0]))),
+        "read_file_full": full_reads,
+        "read_file_sliced": sliced_reads,
+        "repeated_calls": dict(sorted(repeated_calls.items(), key=lambda kv: (-kv[1], kv[0]))),
+        "edit_pattern_sizes": {
+            "count": len(edit_pattern_sizes),
+            "max": max(edit_pattern_sizes) if edit_pattern_sizes else 0,
+            "p95": int(sorted(edit_pattern_sizes)[max(0, int(len(edit_pattern_sizes) * 0.95) - 1)]) if edit_pattern_sizes else 0,
+        },
+    }
+
+
+@dataclass(frozen=True)
+class Scenario:
+    name: str
+    build: Callable[[Path], Dict[str, Any]]
+    prompt: Callable[[Dict[str, Any]], str]
+    verify: Callable[[Dict[str, Any]], Tuple[bool, str]]
+
+
+def _make_python_scenario() -> Scenario:
+    def build(root: Path) -> Dict[str, Any]:
+        path = root / "main.py"
+
+        filler = "\n".join([f"# filler {i}" for i in range(1, 460)])  # >400 lines to refuse full read_file
+        path.write_text(
+            "\n".join(
+                [
+                    "class Player:",
+                    "    def __init__(self):",
+                    "        # BUG: this should store the provided color",
+                    "        self.color = None",
+                    "",
+                    "def main():",
+                    "    p = Player('blue')",
+                    "    return p.color",
+                    "",
+                    filler,
+                    "",
+                    "if __name__ == '__main__':",
+                    "    print(main())",
+                    "",
+                ]
+            ),
+            encoding="utf-8",
+        )
+
+        return {"file_path": str(path)}
+
+    def prompt(ctx: Dict[str, Any]) -> str:
+        return (
+            "Fix the following runtime error:\n"
+            "TypeError: Player.__init__() takes 1 positional argument but 2 were given\n\n"
+            f"Target file: {ctx['file_path']}\n\n"
+            "Constraints:\n"
+            "- Do NOT try to read the entire file (it is >400 lines; read_file(full) will refuse).\n"
+            "- Use analyze_code() first to locate the Player definition.\n"
+            "- Then use read_file(start_line/end_line) around the relevant blocks.\n"
+            "- Apply small, surgical edit_file() calls (short patterns; max_replacements=1).\n\n"
+            "Expected fix:\n"
+            "- Player.__init__ should accept an optional color parameter and set self.color\n"
+            "- Replace the \"self.color = None\" line with \"self.color = color\".\n"
+            "- Keep behavior otherwise unchanged.\n"
+        )
+
+    def verify(ctx: Dict[str, Any]) -> Tuple[bool, str]:
+        text = Path(ctx["file_path"]).read_text(encoding="utf-8")
+        def _sig_has_color(start_idx: int) -> bool:
+            if start_idx < 0:
+                return False
+            window = text[start_idx : start_idx + 300]
+            # Check only inside the signature portion (best-effort).
+            sig_end = window.find("):")
+            if sig_end == -1:
+                sig_end = window.find("):\n")
+            if sig_end == -1:
+                sig_end = window.find("):\r\n")
+            if sig_end == -1:
+                sig_end = min(len(window), 120)
+            signature = window[:sig_end]
+            return "color" in signature
+
+        player_idx = text.find("class Player")
+        ok_player = player_idx != -1 and _sig_has_color(text.find("def __init__", player_idx))
+        if ok_player:
+            window = text[player_idx : player_idx + 300]
+            ok_player = "self.color = color" in window or "self.color=color" in window
+
+        if ok_player:
+            return True, "Player constructor updated with color parameter."
+        return False, "Did not find expected __init__ signature/body update for Player."
+
+    return Scenario(name="python_ctor_mismatch_large_file", build=build, prompt=prompt, verify=verify)
+
+
+def _make_js_scenario() -> Scenario:
+    def build(root: Path) -> Dict[str, Any]:
+        path = root / "app.js"
+        filler = "\n".join([f"// filler {i}" for i in range(1, 460)])  # >400 lines to discourage full read_file
+        path.write_text(
+            "\n".join(
+                [
+                    "export function greet(name) {",
+                    "  return `Hello ${name}`;",
+                    "}",
+                    "",
+                    "export function run() {",
+                    "  // BUG: wrong function name",
+                    "  return greets('world');",
+                    "}",
+                    "",
+                    filler,
+                    "",
+                    "console.log(run());",
+                    "",
+                ]
+            ),
+            encoding="utf-8",
+        )
+        return {"file_path": str(path)}
+
+    def prompt(ctx: Dict[str, Any]) -> str:
+        return (
+            "Fix the following JavaScript error:\n"
+            "ReferenceError: greets is not defined\n\n"
+            f"Target file: {ctx['file_path']}\n\n"
+            "Constraints:\n"
+            "- Use analyze_code() first to locate greet/run.\n"
+            "- Use read_file(start_line/end_line) around the run() function.\n"
+            "- Make a minimal edit_file() change: call greet('world') instead of greets('world').\n"
+        )
+
+    def verify(ctx: Dict[str, Any]) -> Tuple[bool, str]:
+        text = Path(ctx["file_path"]).read_text(encoding="utf-8")
+        if "return greet('world');" in text:
+            return True, "Fixed call to greet()."
+        return False, "Did not find expected replacement greets(...) -> greet(...)."
+
+    return Scenario(name="js_reference_error", build=build, prompt=prompt, verify=verify)
+
+
+def _print_heading(title: str) -> None:
+    print("\n" + "=" * 80)
+    print(title)
+    print("=" * 80)
+
+
+def _run_scenarios(*, scenarios: List[Scenario]) -> int:
+    provider, model, llm_kwargs = _llm_config()
+    _print_heading(f"LMStudio Tool Eval | provider={provider} | model={model} | base_url={llm_kwargs.get('base_url') or '(default)'}")
+
+    from abstractagent.agents.react import create_react_agent
+
+    run_stamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%SZ")
+    out_root = Path(os.getenv("AF_TOOL_EVAL_OUT_DIR", "test_results/tool_eval")).expanduser().absolute()
+    out_root.mkdir(parents=True, exist_ok=True)
+    run_dir = out_root / f"lmstudio_tool_eval_{run_stamp}"
+    run_dir.mkdir(parents=True, exist_ok=True)
+
+    aggregate: List[Dict[str, Any]] = []
+
+    for s in scenarios:
+        with tempfile.TemporaryDirectory(prefix="af_tool_eval_") as td:
+            root = Path(td)
+            ctx = s.build(root)
+            scenario_dir = run_dir / s.name
+            scenario_dir.mkdir(parents=True, exist_ok=True)
+
+            agent = create_react_agent(
+                provider=provider,
+                model=model,
+                llm_kwargs=llm_kwargs,
+                max_iterations=20,
+                max_tokens=8192,
+            )
+
+            agent.start(s.prompt(ctx))
+            state = agent.run_to_completion()
+
+            traces = agent.get_node_traces()
+            events = _iter_tool_calls(traces)
+            summary = _summarize_tool_usage(events)
+
+            ok, msg = s.verify(ctx)
+            answer = ""
+            try:
+                answer = str((state.output or {}).get("answer") or "")
+            except Exception:
+                answer = ""
+
+            record = {
+                "scenario": s.name,
+                "status": getattr(state.status, "value", str(state.status)),
+                "verify_ok": ok,
+                "verify_msg": msg,
+                "tool_summary": summary,
+                "answer": answer,
+            }
+            aggregate.append(record)
+
+            _print_heading(f"Scenario: {s.name}")
+            print(f"Run status: {record['status']} | verify_ok={ok}")
+            print(f"Verify: {msg}")
+            print("Tool counts:", summary["tool_counts"])
+            if summary["failures"]:
+                print("Tool failures:", summary["failures"])
+            print(f"read_file(full)={summary['read_file_full']} | read_file(slice)={summary['read_file_sliced']}")
+            if summary["repeated_calls"]:
+                # Print only the top few repeated calls to keep output small.
+                top = list(summary["repeated_calls"].items())[:3]
+                print("Repeated identical calls (top 3):", {k: v for k, v in top})
+
+            # Persist scenario traces + final file snapshot for deep inspection.
+            try:
+                (scenario_dir / "node_traces.json").write_text(_json_key(traces), encoding="utf-8")
+                (scenario_dir / "summary.json").write_text(_json_key(record), encoding="utf-8")
+                file_path = Path(str(ctx.get("file_path") or "")).expanduser()
+                if file_path.exists() and file_path.is_file():
+                    (scenario_dir / f"final_{file_path.name}").write_text(file_path.read_text(encoding="utf-8"), encoding="utf-8")
+            except Exception:
+                pass
+
+    # Aggregate: report issues that repeat across scenarios.
+    _print_heading("Aggregate (repetitive-only)")
+    repeats: Dict[str, int] = {}
+    for r in aggregate:
+        ts = r.get("tool_summary") or {}
+        if isinstance(ts, dict):
+            if (ts.get("read_file_full") or 0) > 0:
+                repeats["read_file_full_used"] = repeats.get("read_file_full_used", 0) + 1
+            tool_counts = ts.get("tool_counts") or {}
+            if isinstance(tool_counts, dict) and tool_counts.get("analyze_code", 0) == 0:
+                repeats["analyze_code_not_used"] = repeats.get("analyze_code_not_used", 0) + 1
+            failures = ts.get("failures") or {}
+            if isinstance(failures, dict) and failures.get("edit_file", 0) > 0:
+                repeats["edit_file_failures"] = repeats.get("edit_file_failures", 0) + 1
+
+    if not repeats:
+        print("No repetitive issues detected across scenarios (based on basic heuristics).")
+    else:
+        for k, v in sorted(repeats.items(), key=lambda kv: (-kv[1], kv[0])):
+            if v > 1:
+                print(f"- {k}: occurred in {v}/{len(aggregate)} scenarios")
+
+    print(f"\nSaved eval artifacts to: {run_dir}")
+
+    # Exit code: non-zero if any scenario verification failed.
+    failed = [r for r in aggregate if not r.get("verify_ok")]
+    if failed:
+        print(f"\nFailures: {len(failed)}/{len(aggregate)} scenarios did not meet verification checks.")
+        for r in failed:
+            print(f"- {r['scenario']}: status={r['status']} verify={r['verify_msg']}")
+        return 1
+    return 0
+
+
+def main() -> int:
+    scenarios = [_make_python_scenario(), _make_js_scenario()]
+    return _run_scenarios(scenarios=scenarios)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

abstractagent/tools/__init__.py

@@ -7,6 +7,7 @@ Agent-specific tools (execute_python, self_improve) are defined locally.
 # Import common tools from AbstractCore (canonical source)
 from abstractcore.tools.common_tools import (
     list_files,
+    analyze_code,
     read_file,
     search_files,
     write_file,
@@ -24,6 +25,7 @@ from .self_improve import self_improve
 ALL_TOOLS = [
     # File operations (from abstractcore)
     list_files,
+    analyze_code,
     read_file,
     search_files,
     write_file,
@@ -41,6 +43,7 @@ ALL_TOOLS = [
 __all__ = [
     # File operations
     "list_files",
+    "analyze_code",
     "read_file",
     "search_files",
     "write_file",

{abstractagent-0.2.0.dist-info → abstractagent-0.3.0.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: abstractagent
-Version: 0.2.0
+Version: 0.3.0
 Summary: Agent implementations using AbstractRuntime and AbstractCore
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: abstractcore
+Requires-Dist: abstractcore[tools]
 Requires-Dist: abstractruntime
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
@@ -18,7 +18,7 @@ Agent implementations using AbstractRuntime and AbstractCore.
 ## Features
 
 - **ReAct Agent**: Reason-Act-Observe loop with tool calling
-- **Async REPL**: Interactive agent with real-time step visibility
+- **Host UX in AbstractCode**: the interactive terminal shell lives in **AbstractCode**; AbstractAgent stays focused on agent patterns/workflows
 - **Pause/Resume**: Durable agent state with interrupt/resume capability
 - **Ask User**: Agent can ask questions with multiple choice + free text
 - **Ledger Recording**: All tool calls recorded for auditability
@@ -102,11 +102,11 @@ state = agent.run_to_completion()
 agent.clear_state("agent_state.json")
 ```
 
-## REPL Usage
+## Interactive Shell (AbstractCode)
 
 ```bash
-# Start the ReAct agent REPL
-python -m abstractagent.repl --provider ollama --model qwen3:4b-instruct-2507-q4_K_M
+# The interactive REPL moved to AbstractCode (host UX).
+abstractcode --agent react --provider ollama --model qwen3:4b-instruct-2507-q4_K_M
 ```
 
 ## Architecture
@@ -127,8 +127,7 @@ AbstractAgent
 
 ## Available Tools
 
-- `list_files(path)` - List files and directories
-- `read_file(path)` - Read file contents
-- `search_files(pattern, path)` - Search for files matching a glob pattern
-- `execute_command(command)` - Execute a shell command (with safety restrictions)
-- `ask_user(question, choices)` - Ask the user a question (built-in)
+- Default tool callables are re-exported from AbstractCore in `abstractagent.tools` (file ops, web tools, `execute_command`), plus:
+  - `execute_python(code, timeout_s=...)`
+  - `self_improve(suggestion, ...)`
+- The agent also exposes schema-only built-ins (`ask_user`, `recall_memory`, `inspect_vars`, `remember`, `compact_memory`) which are translated into **Runtime effects** by the workflow adapters (durable; no callable persistence).

abstractagent-0.3.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+abstractagent/__init__.py,sha256=-o1xKOyT3rhA67Iey2RCeZzU5SiFLB1mX4F2tAKH98Y,948
+abstractagent/repl.py,sha256=6TWVxEYAAXLR5jjrc3FKmEy4Sm4xzdX5REQKx-lH35g,1089
+abstractagent/adapters/__init__.py,sha256=k_7Lz8nOoMHmGeYrSbIMtLXIvmqJTzOo33g7v8C-qrM,284
+abstractagent/adapters/codeact_runtime.py,sha256=VkmU1LO-5kr6GtKl4S7IeOorbOtE1GUtc6wGmbPzVEk,48774
+abstractagent/adapters/memact_runtime.py,sha256=o_IuAIZTK_Nafp0hNwWBiPBSuyfRzU7SqL9rCuKCekg,29567
+abstractagent/adapters/react_runtime.py,sha256=XEJlAoh3E9cgLfF8D2bDVgdp2Ya0l8RxxM6AGJ4gS4E,63871
+abstractagent/agents/__init__.py,sha256=9U15lIVgGBZVsmDCKtz4AyTJFTI3nUq4ej8Ugk8lvhM,548
+abstractagent/agents/base.py,sha256=HfGvkD24lBCEDbhwjDf4vtmrxti_fyrhMW3AjP12eu0,16745
+abstractagent/agents/codeact.py,sha256=lvt_kgT3DuqOHeOPEyKTzm7H3mbBEk6tiMwMzGcQjIg,9680
+abstractagent/agents/memact.py,sha256=tHemdUSC7vZUFFUznZ0FEJMOnjRZQU9oIx-FiR7FGN8,8648
+abstractagent/agents/react.py,sha256=vxS2vna_gANvGhrEzAUOIfWJljbHeFAZt5tE846Lvp4,10107
+abstractagent/logic/__init__.py,sha256=QeUxFEyaoi4ymPVEwno1mirBpMP77EtWJa-pTHakY2g,524
+abstractagent/logic/builtins.py,sha256=I2IMrTIZmy0j9xOJkuOxgpu4fUMy6cwvdyy545a_HRI,8605
+abstractagent/logic/codeact.py,sha256=BphuRhGL4T0QCoD6fcVDhgx3TQG5Vl4c-L6iKfeI-9o,6480
+abstractagent/logic/memact.py,sha256=v6v5vV79nJvALpvl8vXJJhRY_j0GaM22t6sJAGN661A,4753
+abstractagent/logic/react.py,sha256=SHU1YUE8uT_uuvq7CH2zY51rozAtHtVutS4NICJvep0,8154
+abstractagent/logic/types.py,sha256=idLhxgBaN3LY7tDmwMNL9hgWCKM5P1BRNv5YYkXMy80,595
+abstractagent/sandbox/__init__.py,sha256=Vay_BJzmfMcf-cAUoapDbckCyhHGQHFzObVR98x2j3g,186
+abstractagent/sandbox/interface.py,sha256=DtL_RYaXgPojW-vUIgEPi_69sleSNQU-YCWrwZ_WSoI,462
+abstractagent/sandbox/local.py,sha256=mFQzFgec0qgJ8VNbB0ZjeZi58BgrIE0frMFsasKe3iI,2143
+abstractagent/scripts/__init__.py,sha256=paHuNvq6FzV1nVyGV-ixPW8K1rumoLpSvwcMIbP0y8U,130
+abstractagent/scripts/lmstudio_tool_eval.py,sha256=FX_rvbLFY0KeT38i2e4p6htffzEiAR1mBXQhd6dK3zE,16568
+abstractagent/tools/__init__.py,sha256=wDoWaQ2XqvLChMuXhQspXrdb-RyFWtBp6HQbUM3gGMc,1252
+abstractagent/tools/code_execution.py,sha256=rQBJXfTGdCxVSr7SqTH17mQ9ylImNDcT5R7_bBIvygA,1417
+abstractagent/tools/self_improve.py,sha256=yOtsa0iS5OxVPLpu3MN_fPxPTEMl3Qnm1GWYJHFsZe8,1732
+abstractagent-0.3.0.dist-info/licenses/LICENSE,sha256=6rL4UIO5IdK59THf7fx0q6Hmxp5grSFi7-kWLcczseA,1083
+abstractagent-0.3.0.dist-info/METADATA,sha256=mgdP9LfNgeQ5HOqUVLx7RijgHBWNUzc2kjtHrrRDI8A,3513
+abstractagent-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstractagent-0.3.0.dist-info/entry_points.txt,sha256=tEaR0KtY-chcgRTd6ZVkvsqqaDpw2rvi-1RFktHGczU,56
+abstractagent-0.3.0.dist-info/top_level.txt,sha256=cgtC3Vjz_piTAMmRkd73tbUxk2jPeG3IxMbo7JK3RTU,14
+abstractagent-0.3.0.dist-info/RECORD,,

abstractagent/ui/__init__.py

@@ -1,5 +0,0 @@
-"""UI components for AbstractAgent."""
-
-from .question import QuestionUI, render_question, get_user_response
-
-__all__ = ["QuestionUI", "render_question", "get_user_response"]