Merge master into the OpenCode Go branch

Master grew Google AI Studio and Antigravity as providers, a doctor that names each provider's own key, and settings that fetch every hosted model list as the window opens. OpenCode Go is folded into each: its name joins SERVICES and the doctor's key table, its key row sits beside Google's, its Fetch button follows the per-provider pattern Google's uses, and _load_hosted_models fetches its catalog at open when a key is on file, filling the cleanup and agent boxes alike.
2026-09-11 19:06:11 +00:00 · 2026-08-27 16:27:57 +03:00
parent fa3d72f5a7 5fd32d105f
commit 22a73bd939
18 changed files with 1242 additions and 231 deletions
@@ -1,23 +1,29 @@
 """Handing a dictation to an agent as a command, and pasting back its answer.

-Four of them, because not everyone has the same one installed:
+Five of them, because not everyone has the same one installed:

  Claude Code   `claude -p`, the session you would have opened yourself
  Codex         `codex exec`, the same idea from the other shop
+  Antigravity   `agy -p`, Google's, with a browser of its own attached
  OpenRouter    a plain chat request, over the key that is already configured
  OpenCode Go   a plain chat request, over a subscription to open coding models

-The first two are the whole machine: they run commands, read files, and reach
+The first three are the whole machine: they run commands, read files, and reach
 whatever skills and services you have connected, which is what makes "put that
 in my calendar on Thursday" a thing you can say. The two chat requests cannot
 touch any of that, and are there so that a question still gets an answer on a
-machine with neither CLI installed.
+machine with no CLI installed at all.
+
+What each of the three is allowed to do without asking is settled where that
+program keeps its own permissions, not here. Dikte hands Claude Code the mode
+chosen in Settings because it has a flag for one; Codex gets a sandbox for the
+same reason; Antigravity has neither, and reads its own allow-rules instead.

 Whichever it is, the reply is pasted exactly where the transcript would have
 been, and the conversation carries across dictations so that "and move that to
 Friday" knows what "that" is.

-The two CLIs are read as they stream rather than waited out. A command that
+The three CLIs are read as they stream rather than waited out. A command that
 reaches for the calendar or the web takes long enough that a still indicator is
 indistinguishable from a hang, so every tool they pick up is named in the corner
 while they work.
@@ -39,7 +45,12 @@ from . import paths
 from .i18n import t

 SESSION_FILE = cfg.DATA_DIR / "assistant.json"
-PROVIDERS = ("claude", "codex", "openrouter", "opencode")
+PROVIDERS = ("claude", "codex", "agy", "openrouter", "opencode")
+
+# What each one is called where a person reads it: the tray, the corner of
+# the screen, and the line an error is written in.
+SERVICES = {"claude": "Claude", "codex": "Codex", "agy": "Antigravity",
+            "openrouter": "OpenRouter", "opencode": "OpenCode Go"}

 # How many messages of a chat provider's conversation are carried forward. The
 # two CLIs keep their own history and need no such number; here every turn is
@@ -71,6 +82,29 @@ CODEX_ITEMS = {
    "patch_apply": "Editing a file…",
    "todo_list": "Planning…",
 }
+# Antigravity carries a browser around with it, so the handful of names below
+# stand in for the couple of dozen browser_* tools it can pick up; being told
+# which mouse button moved is not what the corner of the screen is for.
+AGY_TOOLS = {
+    "run_command": "Running a command…",
+    "command_status": "Running a command…",
+    "send_command_input": "Running a command…",
+    "view_file": "Reading…",
+    "read_url_content": "Reading a web page…",
+    "list_dir": "Looking through files…",
+    "find_by_name": "Looking through files…",
+    "grep_search": "Searching the files…",
+    "search_web": "Searching the web…",
+    "replace_file_content": "Editing a file…",
+    "multi_replace_file_content": "Editing a file…",
+    "sed_file": "Editing a file…",
+    "notebook_edit": "Editing a file…",
+    "write_to_file": "Writing a file…",
+    "generate_image": "Drawing…",
+    "manage_task": "Planning…",
+    "invoke_subagent": "Handing it to a subagent…",
+    "browser_subagent": "Handing it to a subagent…",
+}


 # How hard to think, in each provider's own vocabulary. The setting is one
@@ -86,6 +120,12 @@ CLAUDE_EFFORT = {"none": "low", "minimal": "low", "low": "low",
 CODEX_EFFORT = {"none": "low", "minimal": "low", "low": "low",
                "medium": "medium", "high": "high", "xhigh": "high",
                "max": "high"}
+# agy has three rungs and no word for off, so the bottom of the ladder lands on
+# "low" and the top two on "high". Shared with cleanup, which runs the same
+# program for the smaller job.
+AGY_EFFORT = {"none": "low", "minimal": "low", "low": "low",
+              "medium": "medium", "high": "high", "xhigh": "high",
+              "max": "high"}


 class AssistantError(Exception):
@@ -103,14 +143,30 @@ def provider(conf):

 def executable(name):
    """The CLI a provider runs, or "" when it needs none."""
-    return {"claude": "claude", "codex": "codex"}.get(name, "")
+    return {"claude": "claude", "codex": "codex", "agy": "agy"}.get(name, "")
+
+
+def model(conf):
+    """Which model answered, for the history to record.
+
+    Each provider keeps its own setting, and the one a CLI is left on has no id
+    to report, only a name — the same arrangement cleanup.model() makes.
+    """
+    name = provider(conf)
+    if name == "codex":
+        return conf["assistant_codex_model"].strip() or "codex"
+    if name == "agy":
+        return conf["assistant_agy_model"].strip() or "agy"
+    if name == "openrouter":
+        return conf["assistant_openrouter_model"]
+    if name == "opencode":
+        return conf["assistant_opencode_model"]
+    return conf["assistant_model"]


 def display_name(conf):
    """What to call the thing being asked, in the tray and in the corner."""
-    names = {"claude": "Claude", "codex": "Codex",
-             "openrouter": "OpenRouter", "opencode": "OpenCode Go"}
-    return names.get(provider(conf), "OpenRouter")
+    return SERVICES.get(provider(conf), "OpenRouter")


 # --- the conversation -----------------------------------------------------
@@ -201,8 +257,7 @@ def ask(prompt, conf, on_stage=None, should_stop=None):
    """
    name = provider(conf)
    if name in ("openrouter", "opencode"):
-        service = "OpenRouter" if name == "openrouter" else "OpenCode Go"
-        return _ask_chat(name, service, prompt, conf, on_stage)
+        return _ask_chat(name, SERVICES[name], prompt, conf, on_stage)

    binary = executable(name)
    if not shutil.which(binary):
@@ -211,7 +266,7 @@ def ask(prompt, conf, on_stage=None, should_stop=None):
            "Settings → Agent.", binary=binary,
        ))

-    run = _ask_claude if name == "claude" else _ask_codex
+    run = {"claude": _ask_claude, "codex": _ask_codex, "agy": _ask_agy}[name]
    session = read_session(name, conf["assistant_session_minutes"] * 60)
    try:
        return run(prompt, conf, session, on_stage, should_stop)
@@ -263,7 +318,7 @@ def _ask_claude(prompt, conf, session, on_stage, should_stop):
            found["warning"] = _denial_warning(event)

    code, stderr = _stream(cmd, conf, on_event, should_stop)
-    return _conclude(found, code, stderr, session, "Claude")
+    return _conclude(found, code, stderr, session, "claude")


 def _claude_label(block):
@@ -331,7 +386,7 @@ def _ask_codex(prompt, conf, session, on_stage, should_stop):
                                else str(error)) or t("Codex ended with an error.")

    code, stderr = _stream(cmd, conf, on_event, should_stop)
-    return _conclude(found, code, stderr, session, "Codex")
+    return _conclude(found, code, stderr, session, "codex")


 def _codex_label(item):
@@ -370,6 +425,97 @@ def codex_models():
    return [row["slug"] for row in rows]


+# --- Antigravity ----------------------------------------------------------
+
+def _ask_agy(prompt, conf, session, on_stage, should_stop):
+    # Antigravity takes no system prompt of its own either, so the instruction
+    # rides in front of the command, kept apart from it so the two are not read
+    # as one.
+    body = f"{conf.assistant_prompt()}\n\n---\n\n{prompt}"
+    cmd = [
+        "agy", "-p", body,
+        "--output-format", "stream-json",
+        # agy stops after five minutes unless it is told otherwise, which is
+        # shorter than the timeout this setting offers.
+        "--print-timeout", f"{conf['assistant_timeout']}s",
+    ]
+    # One or the other, always: left with neither, agy picks up whichever
+    # project it was last in and works in that project's directory rather than
+    # the one _stream is about to start it in.
+    cmd += ["--conversation", session] if session else ["--new-project"]
+    if conf["assistant_agy_model"].strip():
+        cmd += ["--model", conf["assistant_agy_model"].strip()]
+    effort = AGY_EFFORT.get(conf["assistant_reasoning"], "")
+    if effort:
+        # Most of agy's own model ids carry the effort in their suffix already;
+        # this is for the ones that do not.
+        cmd += ["--effort", effort]
+
+    found = {"answer": "", "warning": "", "session": "", "failure": ""}
+
+    def on_event(event):
+        kind = event.get("event")
+        if kind == "init":
+            found["session"] = event.get("conversation_id") or found["session"]
+        elif kind == "step_update":
+            step = event.get("step_update") or {}
+            # A tool is reported twice, once when it starts and once when it is
+            # done; the corner wants the first of those.
+            if (on_stage and step.get("step_type") == "tool"
+                    and step.get("state") == "ACTIVE"):
+                on_stage(_agy_label(step))
+        elif kind == "result":
+            result = event.get("result") or {}
+            found["session"] = result.get("conversation_id") or found["session"]
+            answer = (result.get("response") or "").strip()
+            if result.get("status") == "SUCCESS":
+                found["answer"] = answer
+            else:
+                found["failure"] = answer or t("{service} ended with an error.",
+                                               service="Antigravity")
+
+    code, stderr = _stream(cmd, conf, on_event, should_stop)
+    return _conclude(found, code, stderr, session, "agy")
+
+
+def _agy_label(step):
+    name = step.get("tool_name", "")
+    if name in AGY_TOOLS:
+        return t(AGY_TOOLS[name])
+    if name.startswith("browser_") or name.startswith("capture_browser"):
+        return t("Working in the browser…")
+    if name == "call_mcp_tool":
+        server = (step.get("tool_info") or {}).get("parameters") or {}
+        return t("Using {name}…", name=server.get("server") or "a tool")
+    return t("Using {name}…", name=name or "a tool")
+
+
+def agy_models():
+    """The models Antigravity itself would offer right now, in its own order.
+
+    `agy models` prints one `id<TAB>display name` line per model, so the list
+    is as current as the account behind the CLI. Unlike Codex it asks Google
+    rather than a cache on disk, a couple of seconds the caller spends off the
+    interface thread. A machine without agy, or a call that fails, answers
+    with nothing and the caller keeps its built-in list.
+    """
+    if not shutil.which("agy"):
+        return []
+    try:
+        proc = subprocess.run(["agy", "models"],
+                              capture_output=True, text=True, timeout=30)
+    except (OSError, subprocess.SubprocessError):
+        return []
+    if proc.returncode != 0:
+        return []
+    ids = []
+    for line in (proc.stdout or "").splitlines():
+        model_id, tab, _ = line.partition("\t")
+        if tab and model_id.strip():
+            ids.append(model_id.strip())
+    return ids
+
+
 # --- OpenRouter and OpenCode Go -------------------------------------------

 def _ask_chat(name, service, prompt, conf, on_stage):
@@ -478,8 +624,9 @@ _API_TROUBLE = re.compile(
    r"\b(401|403|429|5\d\d)\b")


-def _conclude(found, code, stderr, session, service):
+def _conclude(found, code, stderr, session, name):
    """Turn what the stream said into an answer, or into the reason there is none."""
+    service = SERVICES.get(name, name)
    if code != 0 and not found["answer"]:
        # A resumed run that died with nothing to show is treated as the
        # session being gone, whatever the wording: this code used to look for
@@ -498,7 +645,7 @@ def _conclude(found, code, stderr, session, service):
    if not found["answer"]:
        raise AssistantError(t("{service} answered with nothing.", service=service))
    if found["session"]:
-        write_session("claude" if service == "Claude" else "codex", found["session"])
+        write_session(name, found["session"])
    return found["answer"], found["warning"]