humanbottasks 0.1.0__py3-none-any.whl

alarm.py

@@ -0,0 +1,62 @@
+"""Task-Eingangs-Alarm: gibt NEUE offene Tasks aus; leere Ausgabe = nichts senden.
+
+Wird als no_agent-Cron-Script genutzt: stdout wird verbatim an Telegram geliefert.
+"""
+import os
+import sqlite3
+
+DB = "C:/Users/marku/humanbottasks/tasks.db"
+STATE = "C:/Users/marku/humanbottasks/data/reported_ids.txt"
+
+
+def _load():
+    if not os.path.exists(STATE):
+        return set()
+    with open(STATE, encoding="utf-8") as f:
+        return {ln.strip() for ln in f if ln.strip()}
+
+
+def _save(ids):
+    os.makedirs(os.path.dirname(STATE), exist_ok=True)
+    with open(STATE, "w", encoding="utf-8") as f:
+        for i in sorted(ids):
+            f.write(i + "\n")
+
+
+def main():
+    if not os.path.exists(DB):
+        return
+    conn = sqlite3.connect(DB)
+    conn.row_factory = sqlite3.Row
+    try:
+        rows = conn.execute(
+            "SELECT * FROM tasks WHERE status='pending' ORDER BY created_at"
+        ).fetchall()
+    except sqlite3.OperationalError:
+        return
+    finally:
+        conn.close()
+
+    if not rows:
+        return
+
+    reported = _load()
+    new = [r for r in rows if r["id"] not in reported]
+
+    # Zustand synchron halten (auch bereits bekannte pending merken)
+    _save([r["id"] for r in rows])
+
+    if not new:
+        return
+
+    lines = ["\U0001f195 Neue humanbottasks-Task(s):"]
+    for r in new:
+        lines.append(f"  {r['id']}  [{r['task_type']}]  ${r['max_price_usd']:.2f}")
+        lines.append(f"  {r['description']}")
+    lines.append("")
+    lines.append('Erledigen (im Ordner humanbottasks): python fulfill.py done <task_id> "<Ergebnis>"')
+    print("\n".join(lines))
+
+
+if __name__ == "__main__":
+    main()

fulfill.py

@@ -0,0 +1,17 @@
+"""CLI fuer den Menschen: offene Tasks ansehen und erledigen (MVP-Fulfillment)."""
+import sys
+import store as q
+
+q.init()
+
+if len(sys.argv) >= 4 and sys.argv[1] == "done":
+    q.complete(sys.argv[2], " ".join(sys.argv[3:]))
+    print("Erledigt:", sys.argv[2])
+
+rows = q.pending()
+if not rows:
+    print("Keine offenen Tasks.")
+else:
+    for r in rows:
+        print(f"{r['id']}  [{r['task_type']}]  ${r['max_price_usd']:.2f}  {r['description'][:90]}")
+    print("\nErledigen: python fulfill.py done <task_id> <Ergebnis-Text>")

humanbottasks-0.1.0.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.5
+Name: humanbottasks
+Version: 0.1.0
+Summary: Human fallback for AI agents: delegate tasks a model can't do to a human, over MCP.
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: mcp<2
+Description-Content-Type: text/markdown
+
+# humanbottasks
+
+Gemanagter Human-Service-Layer fuer AI-Agenten. Ein AI-Agent delegiert ueber MCP
+eine Aufgabe, die er nicht selbst kann, an einen Menschen; der Mensch erledigt
+sie, der Agent ruft das Ergebnis ab.
+
+## MVP-Status
+- `server.py`   MCP-Server (Tools: request_human_task, get_task_status)
+- `store.py`    SQLite-Queue (tasks.db)
+- `fulfill.py`  CLI fuer den Menschen (Tasks ansehen/erledigen)
+- `demo.py`     End-to-End-Demo (Agent -> Task -> Mensch -> Ergebnis)
+- `test_smoke.py` Smoke-Test
+
+## Setup & Start
+    cd humanbottasks
+    unset PYTHONPATH
+    uv venv
+    uv pip install "mcp<2"
+    uv run server.py
+
+## Transporte
+    uv run server.py                                  # stdio (Claude Desktop, Cursor, lokale Frameworks)
+    uv run server.py --transport streamable-http      # HTTP-Endpoint http://127.0.0.1:8000/mcp (lokal/Remote-Agents)
+    uv run server.py --transport sse                  # Legacy-SSE http://127.0.0.1:8000/sse
+
+Host/Port via Umgebungsvariablen: HBT_HOST (default 127.0.0.1), HBT_PORT (default 8000).
+Fuer Remote-Zugriff: HBT_HOST=0.0.0.0 setzen.
+
+## Install (fuer andere Builder, 1 Zeile)
+    uvx --from git+https://github.com/humanbottasks/humanbottasks humanbottasks
+
+## Task-Typen
+verification · physical_action · subjective_judgment · ground_truth_labeling · prove_human
+
+## MCP-Clients (installiert + konfiguriert)
+- **Claude Desktop**: `C:\Users\marku\AppData\Roaming\Claude\claude_desktop_config.json`
+- **Cursor**: `C:\Users\marku\.cursor\mcp.json`
+- **Windsurf**: `C:\Users\marku\.codeium\windsurf\mcp_config.json`
+- Templates in `config/` (falls neu einrichten noetig)
+
+## Naechste Schritte (Reihenfolge)
+1. Nachfrage-Test: Server laeuft, ein echter Agent ruft request_human_task.
+2. Website/Landing fuer Agent-Builder.
+3. Payments (Stripe/Circle) erst, wenn Nachfrage da ist.

humanbottasks-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+alarm.py,sha256=FT0h1dDwKaXigKt4YFBTlne3OgywM1ZvoK__IF9GUEw,1648
+fulfill.py,sha256=IHwXpEYRFOvWNQrDxt__2xUKg_JBr5aRolpXJPPjEPI,527
+server.py,sha256=W0tLb3d3UGYHu6tQ8KBlQZTAn4oR5JDq3zJJVVYwLfA,2863
+store.py,sha256=UYV8tPNxCNYBmBb8-1cCWe_f174XO2G_KMg4fU7fiCg,1478
+humanbottasks-0.1.0.dist-info/METADATA,sha256=Qu9E725rnZaokyVIFcs4AynbxpPdvfVGAHHZgii_wOs,2095
+humanbottasks-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+humanbottasks-0.1.0.dist-info/entry_points.txt,sha256=R0YGJ1pHHjyLt6avnCEtpPmeKj4nUICjIPPEprSKyzI,46
+humanbottasks-0.1.0.dist-info/licenses/LICENSE,sha256=qtbVlsMaNUW5OdwWSvBd_1VRCGhlWbUif2dvSB1OB6k,1070
+humanbottasks-0.1.0.dist-info/RECORD,,

humanbottasks-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

humanbottasks-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+humanbottasks = server:main

humanbottasks-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 humanbottasks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

server.py

@@ -0,0 +1,83 @@
+"""humanbottasks MCP-Server: AI-Agenten delegieren Tasks an Menschen.
+
+Der Server exponiert zwei Tools ueber MCP:
+  - request_human_task: Agent stellt eine Aufgabe ein
+  - get_task_status:   Agent fragt Status/Ergebnis ab
+
+Transport (--transport): stdio (default), streamable-http, sse.
+
+Ein Mensch erledigt die Tasks ueber fulfill.py (CLI).
+"""
+import os
+from mcp.server.fastmcp import FastMCP
+import store as q
+
+q.init()
+mcp = FastMCP(
+    "humanbottasks",
+    host=os.environ.get("HBT_HOST", "127.0.0.1"),
+    port=int(os.environ.get("HBT_PORT", "8000")),
+)
+
+TASK_TYPES = [
+    "verification",           # etwas pruefen/verifizieren
+    "physical_action",        # physische Handlung (kaufen, verschicken, anrufen, unterschreiben)
+    "subjective_judgment",    # subjektives Urteil (klingt natuerlich? ist gut?)
+    "ground_truth_labeling",  # Daten labeln / Ground-Truth erzeugen
+    "prove_human",            # CAPTCHA / Identitaets-/Konto-Verifikation
+]
+
+
+@mcp.tool()
+def request_human_task(task_type: str, description: str, max_price_usd: float = 10.0) -> str:
+    """Delegiere eine Aufgabe an einen menschlichen Arbeiter.
+
+    Nutze das fuer alles, was du als KI nicht selbst erledigen kannst:
+    physische Aktionen, Verifikation, subjektive Urteile oder Ground-Truth-Labeling.
+
+    Args:
+        task_type: Eine von 'verification', 'physical_action', 'subjective_judgment',
+                   'ground_truth_labeling', 'prove_human'.
+        description: Klare, konkrete Beschreibung der Aufgabe.
+        max_price_usd: Maximalpreis in USD, den du bereit bist zu zahlen.
+
+    Returns:
+        Eine task_id, mit der du den Status abfragen kannst.
+    """
+    if task_type not in TASK_TYPES:
+        return f"Fehler: task_type muss eine von {TASK_TYPES} sein, nicht '{task_type}'."
+    if not description.strip():
+        return "Fehler: description darf nicht leer sein."
+    tid = q.add_task(task_type, description.strip(), max_price_usd)
+    return f"Task angenommen. task_id={tid}. Status: get_task_status('{tid}')."
+
+
+@mcp.tool()
+def get_task_status(task_id: str) -> str:
+    """Status und Ergebnis einer delegierten Task abfragen.
+
+    Args:
+        task_id: Die task_id aus request_human_task.
+
+    Returns:
+        'pending'/'done' plus Ergebnis, wenn fertig.
+    """
+    t = q.get_task(task_id)
+    if not t:
+        return f"Unbekannte task_id: {task_id}"
+    if t["status"] == "done":
+        return f"Fertig. Ergebnis: {t['result']}"
+    return f"Status: {t['status']} (Typ: {t['task_type']}, max ${t['max_price_usd']:.2f})"
+
+
+def main():
+    import argparse
+    p = argparse.ArgumentParser(description="humanbottasks MCP-Server")
+    p.add_argument("--transport", default="stdio",
+                   choices=["stdio", "sse", "streamable-http"])
+    a = p.parse_args()
+    mcp.run(transport=a.transport)
+
+
+if __name__ == "__main__":
+    main()

store.py

@@ -0,0 +1,52 @@
+"""SQLite-Task-Queue fuer humanbottasks (minimales MVP)."""
+import sqlite3, uuid, time, os
+
+DB = os.path.join(os.path.dirname(os.path.abspath(__file__)), "tasks.db")
+
+
+def _conn():
+    c = sqlite3.connect(DB)
+    c.row_factory = sqlite3.Row
+    return c
+
+
+def init():
+    with _conn() as c:
+        c.execute("""CREATE TABLE IF NOT EXISTS tasks (
+            id TEXT PRIMARY KEY,
+            task_type TEXT NOT NULL,
+            description TEXT NOT NULL,
+            max_price_usd REAL NOT NULL,
+            status TEXT NOT NULL DEFAULT 'pending',
+            result TEXT,
+            created_at REAL NOT NULL,
+            completed_at REAL
+        )""")
+
+
+def add_task(task_type, description, max_price_usd):
+    tid = uuid.uuid4().hex[:12]
+    with _conn() as c:
+        c.execute(
+            "INSERT INTO tasks (id, task_type, description, max_price_usd, status, created_at) VALUES (?,?,?,?,?,?)",
+            (tid, task_type, description, max_price_usd, "pending", time.time()),
+        )
+    return tid
+
+
+def get_task(tid):
+    with _conn() as c:
+        return c.execute("SELECT * FROM tasks WHERE id=?", (tid,)).fetchone()
+
+
+def pending():
+    with _conn() as c:
+        return c.execute("SELECT * FROM tasks WHERE status='pending' ORDER BY created_at").fetchall()
+
+
+def complete(tid, result):
+    with _conn() as c:
+        c.execute(
+            "UPDATE tasks SET status='done', result=?, completed_at=? WHERE id=?",
+            (result, time.time(), tid),
+        )