devops-bot-sdk 1.6.84__tar.gz → 1.6.85__tar.gz

{devops_bot_sdk-1.6.84 → devops_bot_sdk-1.6.85}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.6.84
+Version: 1.6.85
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary

{devops_bot_sdk-1.6.84 → devops_bot_sdk-1.6.85}/devops_bot_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.6.84
+Version: 1.6.85
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary

{devops_bot_sdk-1.6.84 → devops_bot_sdk-1.6.85}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -138,6 +138,7 @@ sdk/ui/static/app.js
 sdk/ui/static/chat.html
 sdk/ui/static/custom-agents.html
 sdk/ui/static/default-agents.html
+sdk/ui/static/help.html
 sdk/ui/static/index.html
 sdk/ui/static/report.html
 sdk/ui/static/runs.html
@@ -200,6 +201,7 @@ tests/test_limit_fallback_handoff.py
 tests/test_local_exec_provider.py
 tests/test_mcp_route_contract.py
 tests/test_memory_guard.py
+tests/test_panel_help.py
 tests/test_panel_ticket_schedules.py
 tests/test_phase_timer.py
 tests/test_plan_new_command.py

{devops_bot_sdk-1.6.84 → devops_bot_sdk-1.6.85}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.6.84
+Version: 1.6.85
 
 Public surface:
   BackendClient.from_config()        — create client from ~/.agentos/config.toml
@@ -34,7 +34,7 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.6.84"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.6.85"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
 __author__  = "AgentOS"   # sdk.client.SDK_VERSION and the UI server version all read this.
 
 from sdk.client import BackendClient

{devops_bot_sdk-1.6.84 → devops_bot_sdk-1.6.85}/sdk/helpdesk.py

@@ -16,6 +16,13 @@ log line for every claim and to say "not determinable" rather than guess. It
 cannot run commands, edit files or reach the web, so asking for help can never
 change the machine.
 
+When claude is not installed, not logged in, or fails mid-answer, the AI Draftsman
+fallback (``ad``) answers instead — the same fallback tickets use. ``ad`` has no
+tool allowlist, ``--add-dir`` or system-prompt flag, so the helper compensates:
+``--permission-mode plan`` (its no-changes mode), the SDK source and docs copied
+INTO the case folder (its working directory), and the same rules sent at the top
+of the prompt.
+
 ``agentos doctor`` builds the same case folder with no AI, for sending to an admin.
 """
 from __future__ import annotations
@@ -43,6 +50,11 @@ _RUN_LOGS = 5
 #: Case folders kept; older ones are pruned on each run.
 _KEEP_CASES = 10
 _ANSWER_TIMEOUT_S = 900
+#: A rate-limited `ad` run (its gateway's 429 / RESOURCE_EXHAUSTED) is retried this
+#: many times, this far apart — the quota window is per minute.
+_AD_RATE_LIMIT_RETRIES = 2
+_AD_RATE_LIMIT_WAIT_S = 45.0
+_RATE_LIMIT_RE = re.compile(r"RATE_LIMIT|RESOURCE_EXHAUSTED|\b429\b")
 
 # Secrets that may appear in config, env or logs. Order matters: the specific
 # token shapes first, then the generic key=value catch-all.
@@ -78,7 +90,10 @@ Your evidence, all readable with Read/Grep/Glob:
 - The knowledge base: {kb} — a map of programs, files, known issues and fixes.
 {docs_line}
 Accuracy rules — these override everything else:
-1. Read before you answer. Start with diagnostics.md and errors.md; open the logs
+0. WRITE NOTHING until you have finished reading. Your first actions must be file
+   reads; do not print a heading, a guess or a "Diagnosis" line before that.
+1. Read before you answer. Start with diagnostics.md ("Key facts" at its top are
+   computed by the SDK and are always right) and errors.md; open the logs
    and the source that bear on the problem. Never answer from memory alone.
 2. Every claim about what happened must quote the log line (file + the line) that
    shows it; every claim about how the SDK behaves must cite the source as
@@ -225,6 +240,75 @@ def _panel_log() -> str:
     return ""
 
 
+def key_facts() -> list[str]:
+    """The yes/no state an answer most often gets wrong, computed — not inferred.
+
+    Put at the top of diagnostics.md and into the prompt, so a model never has to
+    work out from raw JSON whether the loop is running (the AI Draftsman fallback
+    once answered "the loop appears to be running" with running_pid null).
+    """
+    def yn(v) -> str:
+        return "YES" if v else "NO"
+
+    facts: list[str] = []
+    try:
+        st = _loop_state()
+        facts.append(f"agentos-auto loop running: {yn(st['running_pid'])}"
+                     + (f" (pid {st['running_pid']})" if st["running_pid"] else ""))
+        facts.append(f"stop flag set (~/.agentos/auto.stop): {yn(st['stop_pending'])}")
+        facts.append(f"ticket in flight: {st['current_ticket'] or 'none'}")
+        facts.append(f"queued ticket batches: {len(st['queue'])}")
+    except Exception as exc:  # noqa: BLE001
+        facts.append(f"agentos-auto loop state: unknown ({exc})")
+    try:
+        facts.append(f"agentd running: {yn(_agentd_state()['alive'])}")
+    except Exception as exc:  # noqa: BLE001
+        facts.append(f"agentd state: unknown ({exc})")
+    try:
+        c = _claude_state()
+        facts.append(f"claude CLI: installed {yn(c.get('installed'))}, "
+                     f"logged in {yn(c.get('logged_in'))}")
+    except Exception as exc:  # noqa: BLE001
+        facts.append(f"claude CLI: unknown ({exc})")
+    try:
+        from sdk import local_exec
+        f = local_exec.fallback_status()
+        facts.append(f"AI Draftsman fallback (ad): installed {yn(f.get('installed'))}, "
+                     f"logged in {yn(f.get('logged_in'))}")
+    except Exception as exc:  # noqa: BLE001
+        facts.append(f"AI Draftsman fallback: unknown ({exc})")
+    return facts
+
+
+def valid_commands() -> dict[str, set[str]]:
+    """Every real ``agentos <noun>`` and ``agentos-auto <cmd>``, read off the source."""
+    import inspect
+
+    from sdk import cli as cli_mod, run_auto
+
+    cli_src, auto_src = inspect.getsource(cli_mod), inspect.getsource(run_auto)
+    auto = set(re.findall(r'cmd == "([\w-]+)"', auto_src))
+    for group in re.findall(r"cmd in \(([^)]*)\)", auto_src):
+        auto |= set(re.findall(r'"([\w-]+)"', group))
+    return {"agentos": set(re.findall(r'noun == "([\w-]+)"', cli_src)),
+            "agentos-auto": auto}
+
+
+def unknown_commands(answer: str) -> list[str]:
+    """Commands written as code in ``answer`` that do not exist in the source."""
+    # One snippet per line, and only spaces/tabs between a program and its
+    # sub-command: "`agentos-auto` loop … `agentos-ui`" is two mentions, not a
+    # command `agentos-auto agentos-ui`.
+    code = "\n".join(re.findall(r"```.*?```", answer, re.S)
+                     + re.findall(r"`([^`\n]+)`", answer))
+    valid = valid_commands()
+    bad: list[str] = []
+    for prog, sub in re.findall(r"(?<![\w-])(agentos-auto|agentos(?!-))[ \t]+([a-z][\w-]*)", code):
+        if sub not in valid[prog] and f"{prog} {sub}" not in bad:
+            bad.append(f"{prog} {sub}")
+    return bad
+
+
 def _log_sources() -> list[tuple[str, Path | str]]:
     """(name in the case folder, source path or literal text)."""
     out: list[tuple[str, Path | str]] = []
@@ -261,6 +345,8 @@ def collect_case(question: str = "") -> Path:
         "# Diagnostics", "",
         f"collected: {datetime.now(timezone.utc).isoformat(timespec='seconds')}",
         f"question: {redact(question) or '(none — doctor run)'}", "",
+        "## Key facts (computed by the SDK — trust these over any inference)",
+        *(f"- {f}" for f in key_facts()), "",
         "## Environment",
         f"- sdk version: {__version__}",
         f"- sdk source: {_SDK_DIR}",
@@ -327,14 +413,118 @@ def _docs_dir() -> Path | None:
     return None
 
 
-def claude_argv(cli: str, question: str, case: Path, *, follow_up: bool = False) -> list[str]:
-    """The read-only `claude -p` invocation for one question."""
+def _system_prompt(case: Path, sdk_dir: Path, kb: Path, docs: Path | None) -> str:
     from sdk import __version__
 
-    docs = _docs_dir()
-    system = SYSTEM_PROMPT.format(
-        sdk_dir=_SDK_DIR, version=__version__, kb=_KB_FILE, case_dir=case,
+    return SYSTEM_PROMPT.format(
+        sdk_dir=sdk_dir, version=__version__, kb=kb, case_dir=case,
         docs_line=(f"- Project docs: {docs}\n" if docs else ""))
+
+
+def _copy_sources(case: Path) -> tuple[Path, Path, Path | None]:
+    """Copy the SDK source (.py/.md/.html/.js) and docs into ``case`` for ``ad``,
+    which can only see its working directory. Returns (sdk dir, kb, docs dir)."""
+    def keep(_dir: str, names: list[str]) -> set[str]:
+        return {n for n in names
+                if n == "__pycache__"
+                or ("." in n and not n.endswith((".py", ".md", ".html", ".js")))}
+
+    sdk_copy = case / "sdk_source"
+    if not sdk_copy.exists():
+        shutil.copytree(_SDK_DIR, sdk_copy, ignore=keep)
+    docs = _docs_dir()
+    docs_copy = None
+    if docs:
+        docs_copy = case / "docs"
+        if not docs_copy.exists():
+            shutil.copytree(docs, docs_copy, ignore=keep)
+    return sdk_copy, sdk_copy / _KB_FILE.name, docs_copy
+
+
+def ad_argv(cli: str, *, follow_up: bool = False) -> list[str]:
+    """The `ad -p` invocation; the prompt goes on stdin (no Windows argv limit)."""
+    from sdk import local_exec
+
+    args = ["-p", "--output-format", "text", "--permission-mode", "plan"]
+    if follow_up:
+        args.append("--continue")
+    return local_exec._fallback_argv(cli, *args)
+
+
+def ad_prompt(question: str, case: Path, *, follow_up: bool = False) -> str:
+    """``ad`` has no system-prompt flag: the rules travel at the top of the prompt,
+    with every path pointing INSIDE the case folder, where the sources were copied."""
+    if follow_up:
+        return question
+    sdk_copy, kb, docs = _copy_sources(case)
+    facts = ""
+    try:
+        diag = (case / "diagnostics.md").read_text(encoding="utf-8")
+        block = diag.split("## Key facts", 1)[1].split("\n## ", 1)[0]
+        facts = "\nKey facts (computed by the SDK — always right):" + block.split("\n", 1)[1]
+    except (OSError, IndexError):
+        pass
+    return (_system_prompt(case, sdk_copy, kb, docs) + facts
+            + "\nAll of the above is in your working directory: ./diagnostics.md, "
+              "./errors.md, ./logs/, ./sdk_source/ (cite it as sdk/<file>.py:<line>)"
+            + (", ./docs/" if docs else "") + ".\n\n"
+            + f"The employee's problem:\n{question}\n")
+
+
+def _engines() -> list[tuple[str, str]]:
+    """Ready answer engines, best first: [("claude", path), ("ad", path)]."""
+    from sdk import local_exec
+
+    out: list[tuple[str, str]] = []
+    cli = local_exec.claude_cli_path()
+    if cli:
+        try:
+            ready = local_exec.claude_status(timeout=15.0).get("logged_in")
+        except Exception:  # noqa: BLE001 — unknown: let the run itself decide
+            ready = True
+        if ready:
+            out.append(("claude", cli))
+    try:
+        fb = local_exec.fallback_status()
+    except Exception:  # noqa: BLE001
+        fb = {}
+    if fb.get("installed") and fb.get("logged_in") and fb.get("path"):
+        out.append(("ad", str(fb["path"])))
+    return out
+
+
+def _answer(engine: tuple[str, str], question: str, case: Path, *, follow_up: bool,
+            echo: bool = True) -> tuple[int, str]:
+    """One answer: ``(exit code, captured text)``. ``echo`` streams it to the
+    terminal (the CLI); without it the text is only returned (the panel)."""
+    import time
+
+    name, cli = engine
+    if name == "claude":
+        argv = claude_argv(cli, question, case, follow_up=follow_up)
+        if echo:
+            return _run(argv, case), ""
+        return _run_capture(argv, case, stdin=None, echo=False)
+    prompt = ad_prompt(question, case, follow_up=follow_up)
+    for attempt in range(_AD_RATE_LIMIT_RETRIES + 1):
+        rc, out = _run_capture(ad_argv(cli, follow_up=follow_up), case, stdin=prompt, echo=echo)
+        if rc == 0:
+            if echo:
+                _check_ad_answer(out)
+            return rc, out
+        if not _RATE_LIMIT_RE.search(out[-4000:]) or attempt == _AD_RATE_LIMIT_RETRIES:
+            return rc, out
+        if echo:
+            print(f"\n(the AI Draftsman service is rate-limited — retrying in "
+                  f"{int(_AD_RATE_LIMIT_WAIT_S)}s, {attempt + 1}/{_AD_RATE_LIMIT_RETRIES})\n")
+        time.sleep(_AD_RATE_LIMIT_WAIT_S)
+    return rc, out
+
+
+def claude_argv(cli: str, question: str, case: Path, *, follow_up: bool = False) -> list[str]:
+    """The read-only `claude -p` invocation for one question."""
+    docs = _docs_dir()
+    system = _system_prompt(case, _SDK_DIR, _KB_FILE, docs)
     argv = [cli, "-p", question,
             "--output-format", "text",
             "--allowedTools", "Read,Grep,Glob",
@@ -357,15 +547,26 @@ def ask(question: str, *, interactive: bool | None = None) -> int:
     case = collect_case(question)
     print(f"   case folder: {case}")
 
-    cli = local_exec.claude_cli_path()
-    if not cli:
-        print("\nDevOps Bot Help needs the Claude Code CLI, which is not installed here.")
+    engines = _engines()
+    if not engines:
+        print("\nDevOps Bot Help needs claude or the AI Draftsman fallback, and neither "
+              "is ready here.")
         print(f"  {local_exec.NO_LOCAL_CLI_MESSAGE}")
         print(f"Meanwhile, send this folder to your admin: {case}")
         return 1
 
+    engine = engines[0]
+    if engine[0] == "ad":
+        print("   (claude is not installed or not logged in — answering with the AI "
+              "Draftsman fallback)")
     print("🤖 DevOps Bot Help is reading your logs and the SDK source …\n")
-    rc = _run(claude_argv(cli, question, case), case)
+    rc = _answer(engine, question, case, follow_up=False)[0]
+    if rc != 0 and len(engines) > 1:
+        # claude started but failed (expired login, usage limit, crash): one retry on ad.
+        engine = engines[1]
+        print(f"\n(claude could not answer, exit {rc} — retrying with the AI Draftsman "
+              "fallback)\n")
+        rc = _answer(engine, question, case, follow_up=False)[0]
     if interactive is None:
         interactive = sys.stdin.isatty()
     while rc == 0 and interactive:
@@ -375,24 +576,155 @@ def ask(question: str, *, interactive: bool | None = None) -> int:
             break
         if not more:
             break
-        rc = _run(claude_argv(cli, more, case, follow_up=True), case)
+        rc = _answer(engine, more, case, follow_up=True)[0]
     if rc != 0:
         print(f"\nThe helper could not finish (exit {rc}). Send this folder to your admin: {case}")
     return rc
 
 
-def _run(argv: list[str], case: Path) -> int:
-    sys.stdout.flush()   # our progress lines must land before claude's answer
+def _run(argv: list[str], case: Path, *, stdin: str | None = None) -> int:
+    sys.stdout.flush()   # our progress lines must land before the answer
     try:
-        return subprocess.run(argv, cwd=str(case), timeout=_ANSWER_TIMEOUT_S).returncode
+        return subprocess.run(argv, cwd=str(case), timeout=_ANSWER_TIMEOUT_S,
+                              input=stdin, text=stdin is not None,
+                              encoding="utf-8" if stdin is not None else None).returncode
     except subprocess.TimeoutExpired:
         print("\n(timed out)")
         return 124
     except OSError as exc:
-        print(f"\ncould not start claude: {exc}")
+        print(f"\ncould not start {Path(argv[0]).name}: {exc}")
         return 1
 
 
+def ad_notes(answer: str) -> list[str]:
+    """The fallback model follows the rules less reliably than claude, so check the
+    one thing that can be checked mechanically — commands — and say so."""
+    notes = ["answered by the AI Draftsman fallback, which is less reliable than "
+             "claude: double-check before acting."]
+    bad = unknown_commands(answer)
+    if bad:
+        notes.append("⚠ these commands in the answer DO NOT EXIST — ignore them: "
+                     + ", ".join(f"`{b}`" for b in bad)
+                     + ". The real ones: `agentos help -h` and the top of `sdk/run_auto.py`.")
+    return notes
+
+
+def _check_ad_answer(answer: str) -> None:
+    print()
+    for note in ad_notes(answer):
+        print(f"— {note}")
+
+
+def _run_capture(argv: list[str], case: Path, *, stdin: str | None,
+                 echo: bool = True) -> tuple[int, str]:
+    """Like _run, but KEEP the output (and echo it live unless ``echo`` is off), so
+    a rate-limit failure can be told apart from any other, the answer can be
+    checked afterwards, and the panel can show it."""
+    sys.stdout.flush()
+    tail: list[str] = []
+    try:
+        proc = subprocess.Popen(argv, cwd=str(case),
+                                stdin=subprocess.PIPE if stdin is not None else subprocess.DEVNULL,
+                                stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                                text=True, encoding="utf-8", errors="replace")
+    except OSError as exc:
+        msg = f"could not start {Path(argv[0]).name}: {exc}"
+        if echo:
+            print("\n" + msg)
+        return 1, msg
+    if stdin is not None:
+        try:
+            proc.stdin.write(stdin)
+            proc.stdin.close()
+        except OSError:
+            pass
+    import time
+    deadline = time.monotonic() + _ANSWER_TIMEOUT_S
+    for line in proc.stdout:
+        if echo:
+            sys.stdout.write(line)
+            sys.stdout.flush()
+        tail.append(line)
+        if time.monotonic() > deadline:
+            proc.kill()
+            if echo:
+                print("\n(timed out)")
+            return 124, "".join(tail) + "\n(timed out)"
+    return proc.wait(), "".join(tail)
+
+
+# ── The control panel's Help page ──────────────────────────────────────────
+
+_CASE_NAME_RE = re.compile(r"^case-\d{8}-\d{6}$")
+
+
+def case_path(name: str) -> Path | None:
+    """A case folder by NAME, only if it is one of ours — the panel passes it back."""
+    if not _CASE_NAME_RE.match(name or ""):
+        return None
+    path = _CASES_DIR / name
+    return path if path.is_dir() else None
+
+
+def answer(question: str, case_name: str = "") -> dict:
+    """Blocking, panel-facing ``agentos help``: the same case folder, engines and
+    rules, returned instead of printed.
+
+    A new question builds a new case; ``case_name`` continues that case's
+    conversation on the engine that answered it (`--continue` / `-c`).
+    """
+    from sdk import local_exec
+
+    question = (question or "").strip()
+    if not question:
+        return {"ok": False, "error": "describe the problem first"}
+    follow_up = bool(case_name)
+    if follow_up:
+        case = case_path(case_name)
+        if case is None:
+            return {"ok": False, "error": f"unknown case {case_name!r}"}
+    else:
+        case = collect_case(question)
+
+    engines = _engines()
+    if follow_up:
+        used = (case / "engine.txt").read_text().strip() if (case / "engine.txt").exists() else ""
+        engines = [e for e in engines if e[0] == used] or engines[:1]
+    base = {"case": case.name, "case_path": str(case)}
+    if not engines:
+        return {**base, "ok": False,
+                "error": "neither claude nor the AI Draftsman fallback is ready on this "
+                         f"machine. {local_exec.NO_LOCAL_CLI_MESSAGE}"}
+
+    engine = engines[0]
+    rc, out = _answer(engine, question, case, follow_up=follow_up, echo=False)
+    if rc != 0 and not follow_up and len(engines) > 1:
+        engine = engines[1]
+        rc, out = _answer(engine, question, case, follow_up=False, echo=False)
+    (case / "engine.txt").write_text(engine[0])
+    result = {**base, "ok": rc == 0, "engine": engine[0], "answer": out.strip(),
+              "notes": ad_notes(out) if engine[0] == "ad" and rc == 0 else []}
+    if rc != 0:
+        result["error"] = (f"the helper could not finish (exit {rc}) — send the case "
+                           f"folder to your admin: {case}")
+    return result
+
+
+def bundle_zip(case: Path) -> Path:
+    """A zip of a case's evidence (diagnostics, errors, logs) — NOT the SDK source
+    copied in for `ad`, which the admin already has."""
+    import zipfile
+
+    out = case / f"{case.name}.zip"
+    with zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED) as zf:
+        for path in sorted(case.rglob("*")):
+            rel = path.relative_to(case)
+            if (path.is_file() and path != out
+                    and rel.parts[0] not in ("sdk_source", "docs")):
+                zf.write(path, f"{case.name}/{rel.as_posix()}")
+    return out
+
+
 def doctor() -> int:
     """`agentos doctor` — the case folder only, no AI."""
     case = collect_case()

{devops_bot_sdk-1.6.84 → devops_bot_sdk-1.6.85}/sdk/helpdesk_kb.md

@@ -119,3 +119,8 @@ agentos fallback install | login | status | logout
 agentos doctor                          # collect a diagnostics bundle (no AI)
 agentos help "<problem>"                # this helper
 ```
+
+`agentos help` answers with claude when it is installed and logged in, otherwise
+(or if claude fails mid-answer) with the AI Draftsman fallback `ad`, which must be
+logged in (`agentos fallback login`). With neither ready it only builds the case
+folder — the same bundle `agentos doctor` makes.

{devops_bot_sdk-1.6.84 → devops_bot_sdk-1.6.85}/sdk/local_exec.py

@@ -1099,8 +1099,11 @@ def _setting(key: str) -> str:
 #: The npm package that ships `ad`. It was published as @aidraftsman/cli before 1.1.1.
 FALLBACK_PACKAGE = "@consultancy-outfit/ai-draftsman-cli"
 _LEGACY_FALLBACK_PACKAGES = ("@aidraftsman/cli",)
-#: The oldest `ad` that works against the gateway's Gemini models (see above).
-FALLBACK_MIN_VERSION = (1, 1, 1)
+#: The oldest `ad` to keep. 1.1.1 works against the gateway's Gemini models (see
+#: above); 1.1.2 also retries the gateway's in-stream 429 RESOURCE_EXHAUSTED frame
+#: (ai-draftsman-cli#3) instead of failing the turn — without it a fallback ticket
+#: or `agentos help` dies on the first per-minute quota hit.
+FALLBACK_MIN_VERSION = (1, 1, 2)
 #: How to get the CLI when it is missing — shown in every "not found" message.
 FALLBACK_INSTALL_HINT = f"npm install -g {FALLBACK_PACKAGE}"
 #: `upgrade_fallback_cli` runs at most this often from the start-up path.

{devops_bot_sdk-1.6.84 → devops_bot_sdk-1.6.85}/sdk/ui/api.py

@@ -30,6 +30,7 @@ from sdk.ui.models import (
     CustomAgentCreateRequest,
     CustomAgentUpdateRequest,
     GitActionRequest,
+    HelpAskRequest,
     PromptRegenerateRequest,
     PromptRunRequest,
     PromptVerifyRequest,
@@ -936,6 +937,52 @@ async def agent_run_download(name: str = Query(...), file: str = Query(...)):
 # to the backend `agents` table; the SDK lists/reads/runs them (consume-only).
 
 
+# ── DevOps Bot Help (the panel's Help page; `agentos help` / `agentos doctor`) ──
+
+@router.post("/help/ask", dependencies=[_auth])
+async def help_ask(body: HelpAskRequest) -> dict:
+    """Ask DevOps Bot Help. Runs as a job (an answer takes a minute or more);
+    poll GET /api/ui/jobs/{job_id} → ``{ok, answer, engine, notes, case, error?}``."""
+    import asyncio
+
+    from sdk import helpdesk
+    from sdk.ui import jobs
+
+    async def work() -> dict:
+        return await asyncio.to_thread(helpdesk.answer, body.question, body.case)
+
+    return {"job_id": jobs.start(work())}
+
+
+@router.post("/help/doctor", dependencies=[_auth])
+async def help_doctor() -> dict:
+    """Collect a diagnostics bundle (no AI) — the panel's `agentos doctor`."""
+    import asyncio
+
+    from sdk import helpdesk
+
+    case = await asyncio.to_thread(helpdesk.collect_case)
+    return {"case": case.name, "case_path": str(case),
+            "diagnostics": (case / "diagnostics.md").read_text(encoding="utf-8"),
+            "errors": (case / "errors.md").read_text(encoding="utf-8")}
+
+
+@router.get("/help/case/{name}/bundle", dependencies=[_auth])
+async def help_bundle(name: str):
+    """The case's evidence as a zip, to send to an admin (no SDK source inside)."""
+    import asyncio
+
+    from fastapi.responses import FileResponse
+
+    from sdk import helpdesk
+
+    case = helpdesk.case_path(name)
+    if case is None:
+        raise HTTPException(status_code=404, detail=f"unknown case: {name}")
+    zipped = await asyncio.to_thread(helpdesk.bundle_zip, case)
+    return FileResponse(zipped, media_type="application/zip", filename=zipped.name)
+
+
 @router.get("/jobs/{job_id}", dependencies=[_auth])
 async def job_status(job_id: str) -> dict:
     """Poll a detached job started by a long-running action (chat/analyze/run).

{devops_bot_sdk-1.6.84 → devops_bot_sdk-1.6.85}/sdk/ui/models.py

@@ -684,3 +684,17 @@ class SelfReportEvaluateRequest(BaseModel):
     reason: str = Field(
         "", max_length=500,
         description="Optional note for the audit trail — why it was re-evaluated.")
+
+
+class HelpAskRequest(BaseModel):
+    """Body for ``POST /api/ui/help/ask`` — DevOps Bot Help, from the panel.
+
+    The same helper as ``agentos help``: diagnostics + logs from THIS machine, the
+    installed SDK source, read-only claude (or the AI Draftsman fallback).
+    """
+
+    question: str = Field(..., min_length=1, max_length=4000,
+                          description="The problem, in the employee's own words.")
+    case: str = Field("", max_length=40,
+                      description="A case name from a previous answer, to ask a follow-up "
+                                  "in the same conversation. Empty = a new case.")