ags-cli 0.1.0__tar.gz → 0.2.0__tar.gz

{ags_cli-0.1.0 → ags_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ags-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: AgentS: one unified interface over Claude Code, Google CLI (agy), and OpenAI-compatible local LLMs.
 Author: Platform Engineering
 License: Apache-2.0

{ags_cli-0.1.0 → ags_cli-0.2.0}/ags_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ags-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: AgentS: one unified interface over Claude Code, Google CLI (agy), and OpenAI-compatible local LLMs.
 Author: Platform Engineering
 License: Apache-2.0

ags_cli-0.2.0/harness/adapters/antigravity.py

@@ -0,0 +1,338 @@
+"""AntigravityCliAdapter — drives Google's official ``agy`` CLI.
+
+Empirically verified CLI contract (agy 1.1.27, run live on this machine):
+
+1. **``--output-format stream-json``** — emits NDJSON on stdout, one object per
+   line, with three top-level shapes (``init``, ``step_update``, ``result``). This
+   replaces the old plain-text scraping: we now get tool calls, per-step usage,
+   the conversation id, and the terminal status/denials as structured data.
+2. **Piped stdout works.** The old non-TTY suppression bug (agy emitting 0 bytes
+   when stdout was not a terminal) is fixed upstream, so we run on plain pipes —
+   no PTY, and stderr stays separately captured (under a PTY it was merged into
+   the stream, which is how silent failures used to go unnoticed).
+3. **The prompt goes on stdin.** With no ``-p``/``--prompt`` flag, agy reads the
+   prompt from stdin until EOF. That sidesteps every argv length limit (Windows
+   ``CreateProcess`` 32 KiB / ``cmd.exe`` 8 KiB) and the Go-style flag-parsing
+   hazard where a value-taking flag swallows the next token.
+4. **``--mode plan|accept-edits``** — the permission model. ``plan`` is a real
+   read-only boundary (verified: an explicit "create WROTE.txt" instruction left
+   no file behind). It must be combined with ``--dangerously-skip-permissions``:
+   headless runs cannot prompt, so without it agy auto-denies the first tool that
+   needs a permission and terminates with ``status: "CANCELED"`` and an empty
+   response — a silent no-op run.
+5. **``--conversation <id>``** — resumes a previous conversation by id. The id is
+   inline in every stream-json event, so the old ``--log-file`` glog scraping is
+   gone.
+6. **No ``--mcp-config``** — probe gating handles that (an ``agy mcp`` subcommand
+   exists but takes no run-scoped config file).
+
+Invocation (auth via the CLI's own login or an injected ``ANTIGRAVITY_API_KEY`` /
+``GEMINI_API_KEY`` from a ``secret_ref`` — never token hijacking)::
+
+    agy --output-format stream-json --model <model> --add-dir <cwd> \
+        --print-timeout <N>s --mode plan|accept-edits \
+        --dangerously-skip-permissions [--sandbox] [--conversation <id>]
+    # prompt written to stdin, then closed
+
+The adapter is the abstract "official Google CLI" slot: the binary and flags are
+config-driven (``params.bin`` / ``params.cmd``), so a future successor swaps in via
+config without code changes.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import logging
+import shutil
+import tempfile
+from collections.abc import Iterable
+
+from harness_sdk.base import Capabilities, SessionContext
+from harness_sdk.cli_base import CliSubprocessAdapter, ParserState
+from harness_sdk.events import (
+    AdapterMetaEvent,
+    CostEvent,
+    ErrorEvent,
+    NormalizedEvent,
+    ToolCallEvent,
+    ToolResultEvent,
+    TokenEvent,
+)
+
+from harness.adapters.probe import probe_cli, supports_flag
+from harness.models.enums import AdapterKind
+
+log = logging.getLogger(__name__)
+
+
+class AntigravityCliAdapter(CliSubprocessAdapter):
+    kind = AdapterKind.antigravity
+    # agy streams stream-json fine on a plain pipe as of 1.1.x; a PTY would merge
+    # stderr into stdout and hide failure detail. Overridable via params.pty.
+    default_use_pty = False
+
+    def __init__(self, config) -> None:  # noqa: ANN001 - AdapterConfig
+        super().__init__(config)
+        self._mcp_dirs: dict[str, str] = {}
+        self._probe: dict | None = None
+
+    async def ensure_probe(self) -> dict:
+        """Run ``probe_cli`` once, cache the result on the instance, and return it.
+
+        On any failure returns a safe fallback ``{"ok": False, "flags": set(), "version": None}``
+        so callers never need to guard against exceptions from this method.
+        """
+        if self._probe is not None:
+            return self._probe
+        try:
+            result = await probe_cli(self.binary)
+        except Exception:
+            return {"ok": False, "flags": set(), "version": None}
+        self._probe = result
+        return self._probe
+
+    @property
+    def binary(self) -> str:
+        return self.config.params.get("bin") or self.config.params.get("cmd") or "agy"
+
+    def env_overrides(self) -> dict[str, str]:
+        env: dict[str, str] = {}
+        if self.config.api_key:
+            # agy accepts either; set both so it works regardless of which it reads.
+            env["ANTIGRAVITY_API_KEY"] = self.config.api_key
+            env["GEMINI_API_KEY"] = self.config.api_key
+        # Opt-in managed-skill home. agy's config-dir env var must be verified against
+        # the pinned CLI, so we only set it when explicitly named via params.config_dir_env.
+        from harness.skills import provision_config_home
+        if (envname := self.config.params.get("config_dir_env")) and (
+            home := provision_config_home(self.config.name)
+        ):
+            env[envname] = home
+        return env
+
+    def health_argv(self) -> list[str]:
+        return [self.binary, "--version"]
+
+    async def list_models(self) -> list[str]:
+        """``agy models`` prints a status line, then one TAB-separated
+        ``<id>\\t<display name>`` row per model. Verified against v1.1.27::
+
+            Fetching available models...
+            gemini-3.1-pro-high\\tGemini 3.1 Pro (High)
+
+        We keep the id (field 0) and drop any line without a TAB — that filters the
+        status line and any future chatter without hard-coding its wording.
+        """
+        import asyncio
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                self.binary, "models",
+                stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.DEVNULL,
+                stdin=asyncio.subprocess.DEVNULL,
+            )
+            out, _ = await asyncio.wait_for(proc.communicate(), timeout=20)
+        except (FileNotFoundError, TimeoutError, OSError):
+            return [self.config.model] if self.config.model else []
+        models = [
+            ln.split("\t", 1)[0].strip()
+            for ln in out.decode(errors="replace").splitlines()
+            if "\t" in ln and ln.split("\t", 1)[0].strip()
+        ]
+        return models or ([self.config.model] if self.config.model else [])
+
+    def build_argv(self, *, run_id: str, ctx: SessionContext, message: str) -> list[str]:
+        p = self.config.params
+        argv = [self.binary, "--output-format", "stream-json"]
+        if self.config.model:
+            argv += ["--model", self.config.model]
+        if (cwd := self.working_dir(ctx)):
+            argv += ["--add-dir", cwd]
+        argv += ["--print-timeout", f"{int(self.timeout_s)}s"]
+        if (conv := ctx.extra.get("conversation_id")):
+            argv += ["--conversation", str(conv)]
+        # Safe-by-default: no unattended edits. Write mode (the per-run workspace
+        # mode on the context) lets agy apply changes, in its own sandbox.
+        write = not ctx.read_only
+        argv += ["--mode", "accept-edits" if write else "plan"]
+        # Required on BOTH paths: headless runs cannot answer a permission prompt,
+        # so without this agy auto-denies the first gated tool and the run ends
+        # CANCELED with an empty response. `--mode plan` remains the write barrier.
+        argv.append("--dangerously-skip-permissions")
+        if p.get("sandbox", write):
+            argv.append("--sandbox")
+        argv += self._mcp_argv(run_id, ctx)
+        return argv
+
+    def stdin_payload(self, message: str, ctx: SessionContext | None = None) -> bytes | None:
+        """The prompt goes on stdin (no ``-p``), which agy reads to EOF. System and
+        memory context are prepended — agy has no system-prompt flag."""
+        system = ""
+        if ctx is not None:
+            system = "\n\n".join(x for x in (ctx.system_prompt, ctx.memory_context) if x)
+        prompt = f"{system}\n\n---\n\n{message}" if system else message
+        return prompt.encode("utf-8")
+
+    def _mcp_argv(self, run_id: str, ctx: SessionContext) -> list[str]:
+        """agy is its own MCP client: write the harness-resolved servers to a run-scoped
+        config and point agy at it.
+
+        The flag used (``--mcp-config`` by default) is verified against the probed CLI
+        capability set. If the probe is available and the flag is not supported, MCP
+        servers are skipped (returning ``[]``) and a one-time warning is logged.
+
+        Manual override: setting ``params.mcp_config_flag`` explicitly bypasses probe
+        gating — the user-supplied flag is always passed, letting operators work with
+        pre-release CLIs or renamed flags without a code change."""
+        from harness.mcp import config_gen
+
+        servers = ctx.extra.get("mcp_servers") or []
+        if not servers:
+            return []
+
+        # If the user set an explicit flag, it bypasses probe gating (manual override wins).
+        explicit_flag = self.config.params.get("mcp_config_flag")
+        flag = explicit_flag or "--mcp-config"
+
+        # Probe gating: only applies when no explicit override AND a probe result is cached.
+        if not explicit_flag and self._probe is not None:
+            if not supports_flag(self._probe, flag):
+                log.warning(
+                    "mcp_flag_not_supported_by_cli",
+                    extra={"flag": flag, "binary": self.binary},
+                )
+                log.warning(
+                    "Skipping MCP servers: flag %r not found in %r help output; "
+                    "set params.mcp_config_flag to override",
+                    flag, self.binary,
+                )
+                return []
+
+        d = tempfile.mkdtemp(prefix=f"ags-mcp-{run_id[:8]}-")
+        self._mcp_dirs[run_id] = d
+        path = config_gen.write_json(
+            config_gen.antigravity_mcp_config(servers), d, "mcp.json"
+        )
+        return [flag, path]
+
+    async def _reap(self, proc, run_id: str) -> None:  # noqa: ANN001
+        if (d := self._mcp_dirs.pop(run_id, None)):
+            with contextlib.suppress(Exception):
+                shutil.rmtree(d, ignore_errors=True)
+        await super()._reap(proc, run_id)
+
+    # ── stream-json parsing ───────────────────────────────────────────────────
+    def parse_chunk(self, line: str, state: ParserState) -> Iterable[NormalizedEvent]:
+        line = line.strip()
+        # agy interleaves plain-text progress/diagnostic lines (`jetski: …`) with the
+        # NDJSON stream; they are not part of the answer.
+        if not line.startswith("{"):
+            return
+        try:
+            obj = json.loads(line)
+        except json.JSONDecodeError:
+            return
+        event = obj.get("event")
+        if event == "init":
+            yield from self._conv_meta(obj.get("conversation_id")
+                                       or (obj.get("init") or {}).get("conversation_id"), state)
+        elif event == "step_update":
+            yield from self._parse_step(obj.get("step_update") or {}, state)
+        elif event == "result":
+            yield from self._parse_result(obj.get("result") or {}, state)
+
+    def _conv_meta(self, conv_id, state: ParserState) -> Iterable[NormalizedEvent]:  # noqa: ANN001
+        """Emit the conversation id once per run so the engine can `--conversation`
+        resume the next turn."""
+        if conv_id and state.get("conversation_id") != conv_id:
+            state["conversation_id"] = conv_id
+            yield AdapterMetaEvent(seq=0, data={"conversation_id": str(conv_id)})
+
+    def _parse_step(self, su: dict, state: ParserState) -> Iterable[NormalizedEvent]:
+        yield from self._conv_meta(su.get("conversation_id"), state)
+        step_type = su.get("step_type")
+        step_state = su.get("state")
+
+        if step_type == "agent_response":
+            # `text_delta` is a true incremental delta and is absent on thinking /
+            # tool-planning steps, which carry only `usage`.
+            if (delta := su.get("text_delta")):
+                state.setdefault("text", []).append(delta)
+                yield TokenEvent(seq=0, text=delta)
+        elif step_type == "tool":
+            yield from self._parse_tool_step(su, state, step_state)
+
+        if (usage := su.get("usage")):
+            state["usage"] = usage
+
+    def _parse_tool_step(self, su: dict, state: ParserState,
+                         step_state: str | None) -> Iterable[NormalizedEvent]:
+        info = su.get("tool_info") or {}
+        name = su.get("tool_name") or info.get("name") or "tool"
+        call_id = f"step-{su.get('step_index')}"
+        seen: set[str] = state.setdefault("tool_calls", set())
+        # ACTIVE announces the call; DONE/ERROR carries the outcome. A step can
+        # arrive already DONE (fast tools), so emit the call lazily either way.
+        if call_id not in seen:
+            seen.add(call_id)
+            yield ToolCallEvent(seq=0, name=name,
+                                arguments=info.get("parameters") or {}, call_id=call_id)
+        if step_state in ("DONE", "ERROR"):
+            err = info.get("error") or {}
+            output = err.get("message") if err else info.get("output")
+            yield ToolResultEvent(seq=0, call_id=call_id, output=str(output or ""),
+                                  is_error=bool(err) or step_state == "ERROR")
+
+    def _parse_result(self, res: dict, state: ParserState) -> Iterable[NormalizedEvent]:
+        yield from self._conv_meta(res.get("conversation_id"), state)
+        # `response` is the full consolidated answer — authoritative over the deltas.
+        if (response := res.get("response")):
+            state["final_text"] = response
+        status = str(res.get("status") or "").upper()
+        state["result_status"] = status
+
+        usage = res.get("usage") or state.get("usage") or {}
+        if usage:
+            prompt_tokens = int(usage.get("input_tokens") or 0)
+            completion_tokens = int(usage.get("output_tokens") or 0)
+            yield CostEvent(
+                seq=0,
+                prompt_tokens=prompt_tokens,
+                completion_tokens=completion_tokens,
+                # agy's own `total_tokens` excludes cache reads; keep its arithmetic.
+                total_tokens=int(usage.get("total_tokens")
+                                 or prompt_tokens + completion_tokens),
+                usd=None,  # agy reports no cost; estimate_cost fills it in downstream
+            )
+
+        if status and status != "SUCCESS":
+            denied = [d.get("display_name") or d.get("action")
+                      for d in (res.get("denied_actions") or []) if isinstance(d, dict)]
+            msg = f"agy run ended with status {status}"
+            if denied:
+                msg += f"; denied actions: {', '.join(str(d) for d in denied)}"
+            yield ErrorEvent(seq=0, message=msg, retriable=False)
+
+    def finalize(self, state: ParserState) -> Iterable[NormalizedEvent]:
+        # Consolidate into one canonical assistant message, preferring the result
+        # event's full response over the concatenated deltas.
+        if (final := state.get("final_text")):
+            state["text"] = [final]
+        yield from self._final_text_message(state)
+        # agy exits 0 even for a CANCELED run, so the base class's returncode check
+        # would report "succeeded". Reflect the CLI's own terminal status instead.
+        if state.get("result_status") not in (None, "", "SUCCESS"):
+            if state.get("returncode") in (0, None):
+                state["returncode"] = 1
+
+    def list_capabilities(self) -> Capabilities:
+        return Capabilities(
+            streaming=True,
+            tool_calling=bool(self.config.capabilities.get("tool_calling", True)),
+            max_context=int(self.config.params.get("max_context", 1_000_000)),
+            # agy reports token usage but no price, and we carry no Gemini price
+            # table — so token counts are emitted, USD is not.
+            reasoning=True, cost_known=False,
+            notes=f"Official Google CLI '{self.binary}' (stream-json, token usage).",
+        )

{ags_cli-0.1.0 → ags_cli-0.2.0}/harness/adapters/claude_code.py

@@ -1,5 +1,5 @@
-"""ClaudeCodeAdapter — drives the official ``claude`` CLI (verified against
-v2.1.187).
+"""ClaudeCodeAdapter — drives the official ``claude`` CLI (flag set re-verified
+against v2.1.261).
 
 Invocation (no token hijacking — the CLI uses its own supported auth; an optional
 ``ANTHROPIC_API_KEY`` is injected from a ``secret_ref``):
@@ -42,6 +42,7 @@ from __future__ import annotations
 import contextlib
 import itertools
 import json
+import re
 import shutil
 import tempfile
 from collections.abc import AsyncIterator, Iterable
@@ -131,11 +132,10 @@ class ClaudeCodeAdapter(CliSubprocessAdapter):
         if configured:
             return list(configured)
         return [
-            "claude-fable-5",
+            "claude-opus-5",
+            "claude-fable-5-1",
             "claude-opus-4-8",
-            "claude-opus-4-7",
             "claude-sonnet-5",
-            "claude-sonnet-4-6",
             "claude-haiku-4-5",
         ]
 
@@ -445,7 +445,12 @@ class ClaudeCodeAdapter(CliSubprocessAdapter):
         try:
             obj = json.loads(line)
         except json.JSONDecodeError:
-            return  # non-JSON noise (shouldn't happen with stream-json)
+            # The CLI interleaves plain-text diagnostics with the NDJSON stream, e.g.
+            #   [claude-code:unrecognized_model] {"model":"…","query_source":"sdk"}
+            # Dropping them silently makes a bad `model:` in config look like a
+            # normal (empty) answer, so surface them instead of returning.
+            yield from _diagnostic_events(line)
+            return
         t = obj.get("type")
 
         if t == "system":
@@ -512,6 +517,41 @@ class ClaudeCodeAdapter(CliSubprocessAdapter):
         )
 
 
+_DIAGNOSTIC_RE = re.compile(r"^\[claude-code:([a-z_]+)\]\s*(.*)$")
+
+# Diagnostics that mean the run cannot succeed, mapped to the operator-facing text.
+_FATAL_DIAGNOSTICS = {
+    "unrecognized_model": (
+        "claude does not recognize the configured model {model!r} — it may not exist "
+        "or this account may not have access. Update the provider's `model:` "
+        "(or params.models) in config.yaml."
+    ),
+}
+
+
+def _diagnostic_events(line: str) -> Iterable[NormalizedEvent]:
+    """Turn a plain-text ``[claude-code:<kind>] {json}`` diagnostic into an event.
+
+    Fatal kinds become an ``ErrorEvent`` so a misconfigured model surfaces as a
+    failure rather than an empty run; anything else is passed through as adapter
+    metadata. Unrecognized noise is dropped."""
+    m = _DIAGNOSTIC_RE.match(line)
+    if not m:
+        return
+    kind, payload = m.group(1), m.group(2).strip()
+    try:
+        data = json.loads(payload) if payload else {}
+    except json.JSONDecodeError:
+        data = {"detail": payload}
+    if not isinstance(data, dict):
+        data = {"detail": data}
+    if (template := _FATAL_DIAGNOSTICS.get(kind)):
+        yield ErrorEvent(seq=0, message=template.format(model=data.get("model")),
+                         retriable=False)
+    else:
+        yield AdapterMetaEvent(seq=0, data={"diagnostic": kind, **data})
+
+
 def _stringify(content: object) -> str:
     if isinstance(content, str):
         return content

{ags_cli-0.1.0 → ags_cli-0.2.0}/harness/adapters/probe.py

@@ -8,7 +8,15 @@ from pathlib import Path
 
 from harness_sdk.cli_base import resolve_binary
 
-_FLAG_RE = re.compile(r"(--[a-z][a-z0-9-]+)")
+# Flags are case-SENSITIVE and camelCase is real: `claude --help` advertises
+# `--allowedTools` alongside `--allowed-tools`. A lowercase-only class silently
+# truncated it to `--allowed`, so `supports_flag(probe, "--allowedTools")` was
+# always False and MCP tool pre-authorization was skipped on every run.
+_FLAG_RE = re.compile(r"(--[A-Za-z][A-Za-z0-9-]+)")
+
+# Bumped whenever the parse above changes meaning: entries written by an older
+# parser are ignored (and pruned) instead of short-circuiting the re-parse.
+_PROBE_SCHEMA = 2
 
 
 def _cache_path() -> Path:
@@ -49,11 +57,14 @@ async def probe_cli(binary: str) -> dict:
             cache = json.loads(cache_file.read_text())
         except json.JSONDecodeError:
             cache = {}
-    key = f"{path}::{version}"
+    suffix = f"::v{_PROBE_SCHEMA}"
+    key = f"{path}::{version}{suffix}"
     if key in cache:
         return {"version": version, "flags": set(cache[key]), "ok": True}
     help_text = await _capture([path, "--help"])
     flags = set(_FLAG_RE.findall(help_text))
+    # Drop entries from older parser schemas rather than letting them accumulate.
+    cache = {k: v for k, v in cache.items() if k.endswith(suffix)}
     cache[key] = sorted(flags)
     cache_file.parent.mkdir(parents=True, exist_ok=True)
     cache_file.write_text(json.dumps(cache, indent=1))

{ags_cli-0.1.0 → ags_cli-0.2.0}/harness/memory/context_budget.py

@@ -20,13 +20,19 @@ from harness.models.enums import AdapterKind
 # name — first match wins, so list more specific keys first. Override per provider with
 # ``params.max_context``.
 MODEL_CONTEXT_WINDOWS: dict[str, int] = {
+    "claude-opus-5": 1_000_000,
     "claude-opus-4-8": 1_000_000,
+    "claude-sonnet-5": 1_000_000,
     "claude-sonnet-4-6": 1_000_000,
     "claude-sonnet-4": 1_000_000,
-    "claude-fable-5": 1_000_000,
+    "claude-fable-5": 1_000_000,   # also matches claude-fable-5-1
     "claude-haiku": 200_000,
-    "gemini": 1_000_000,        # 3-pro / 3.1-pro / 3.5-flash all 1M
+    "gemini": 1_000_000,        # every id `agy models` lists is 1M
     "gemma": 131_072,
+    # gpt-oss is served locally (vLLM) and used to fall through to the caller's
+    # per-kind default — 1M under the antigravity kind — so history was never
+    # trimmed and the request overflowed the model instead.
+    "gpt-oss": 131_072,
     "gpt-4o": 128_000,
     "gpt-4.1": 1_000_000,
     "llama": 131_072,

{ags_cli-0.1.0 → ags_cli-0.2.0}/pyproject.toml

@@ -5,7 +5,7 @@
 # either way. The desktop app is unaffected — its PyInstaller build freezes
 # cli/main.py directly and never resolves this name (see ags.spec).
 name = "ags-cli"
-version = "0.1.0"
+version = "0.2.0"
 description = "AgentS: one unified interface over Claude Code, Google CLI (agy), and OpenAI-compatible local LLMs."
 readme = "README.md"
 requires-python = ">=3.12"