@cavi-ai/antigravity 0.2.2 → 0.2.4

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.2.4
+
+- Make the guided-discovery **Reconnect** verification tool-free by installing
+  a bundled, isolated `agy` custom agent for setup probes. Normal provider
+  turns retain the configured Antigravity mode and tool behavior.
+- Declare the native `agy` executable as the CLI backend runtime artifact so
+  current OpenClaw hosts can bind the setup probe to a durable owner.
+- Extend the installed-host integration check through Reconnect activation and
+  isolate its temporary `agy` plugin config from the user's existing plugins.
+- Require Antigravity CLI 1.2.1 or newer for hard tool-free setup probes.
+
+## 0.2.3
+
+- Use OpenClaw's provider-owned guided discovery for Control UI reconnect, the
+  same local-CLI path as Ollama and LM Studio. Models → Providers shows
+  **Reconnect** and persists the non-secret connection without an OpenClaw
+  credential. This replaces the 0.2.2 credential-only Connect routing, which
+  is not a host contract for profileless CLI sessions.
+
 ## 0.2.2
 
 - Route Control UI login through the credential-only provider connection flow.

package/README.md

@@ -18,7 +18,7 @@ ingests and serves at [cavi-ai.xyz/docs/antigravity](https://cavi-ai.xyz/docs/an
 
 - OpenClaw 2026.7 or newer
 - Node.js 20 or newer
-- Antigravity CLI installed and signed in
+- Antigravity CLI 1.2.1 or newer, installed and signed in
 
 Confirm that Antigravity is ready:
 
@@ -37,10 +37,13 @@ Restart the OpenClaw Gateway after installation.
 
 ## Connect
 
-In the Control UI, open **Models → Providers**, choose **Connect**, and select
-**Antigravity CLI**. The plugin validates the existing `agy` session and makes
-its models available without creating a separate credential or changing the
-default model.
+In the Control UI, open **Models → Providers** and choose **Reconnect** on the
+Antigravity CLI card. The plugin validates the existing `agy` session and
+refreshes the provider connection without creating a credential or changing the
+default model. Reconnect installs or refreshes the bundled
+`openclaw-antigravity-tool-free` custom agent, which OpenClaw uses only for its
+connection probe. Normal provider turns keep the configured `agy` mode and tool
+behavior.
 
 ## Use
 
@@ -119,8 +122,19 @@ openclaw config set plugins.entries.antigravity.config.command /absolute/path/to
 ```bash
 npm test          # plugin behaviour
 npm run docs:test # documentation build/verify/release tooling
+npm run check:host-integration # live agy + isolated installed-host Reconnect check
 ```
 
+The host-integration check requires a signed-in `agy` session and a compatible
+installed `openclaw` command. It runs `agy models`, starts the working-tree
+plugin in a temporary loopback-only OpenClaw state, activates the projected
+**Reconnect** action, and verifies that credential-only **Connect** is absent.
+The check links the live `agy` session into a temporary home while keeping its
+plugin configuration isolated. The temporary gateway, home, and state are
+removed afterward; the installed gateway, OpenClaw config, credentials,
+default model, and pre-existing `agy` plugins are not changed. Set `AGY_BIN` or
+`OPENCLAW_BIN` to use a non-default executable.
+
 Releasing docs is automated: publish a GitHub Release `vX.Y.Z` (matching
 `package.json`) and the `Publish release documentation` workflow builds the
 versioned artifact, attaches it to the release, and dispatches cavi-home to

package/agy-plugin/agents/openclaw-antigravity-setup/agent.md

@@ -0,0 +1,11 @@
+---
+name: openclaw-antigravity-setup
+description: Tool-free OpenClaw Antigravity connection probe
+mainAgent: true
+excludeDefaultComponents: true
+inheritCustomizations: false
+---
+
+# Connection probe
+
+Reply directly to the user's message. You have no tools.

package/agy-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "openclaw-antigravity-tool-free",
+  "version": "1.0.0",
+  "description": "Tool-free connection probe for the OpenClaw Antigravity provider",
+  "author": {
+    "name": "CAVI"
+  },
+  "license": "MIT"
+}

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "antigravity",
   "name": "Antigravity CLI",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Runs Google's Antigravity CLI (agy) as a subscription-backed model provider.",
   "enabledByDefault": false,
   "activation": {
@@ -25,13 +25,13 @@
       "provider": "antigravity-cli",
       "method": "cli",
       "choiceId": "antigravity-cli",
-      "credentialOnly": true,
+      "appGuidedDiscovery": true,
+      "appGuidedActionLabel": "Reconnect",
       "choiceLabel": "Antigravity CLI",
       "choiceHint": "Use an existing Antigravity CLI (agy) login on this host. Run `agy models` to confirm.",
       "groupId": "antigravity",
       "groupLabel": "Antigravity",
-      "groupHint": "Subscription-backed models via agy",
-      "onboardingFeatured": true
+      "groupHint": "Subscription-backed models via agy"
     }
   ],
   "uiHints": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cavi-ai/antigravity",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Runs Google's Antigravity CLI (agy) as a subscription-backed OpenClaw model provider.",
   "keywords": [
     "openclaw",
@@ -29,6 +29,8 @@
   },
   "files": [
     "src",
+    "agy-plugin",
+    "scripts/check-host-integration.mjs",
     "setup-api.js",
     "doctor-contract-api.js",
     "openclaw.plugin.json",
@@ -65,6 +67,7 @@
   },
   "scripts": {
     "test": "node --test test/*.test.mjs",
+    "check:host-integration": "node scripts/check-host-integration.mjs",
     "docs:test": "node --test scripts/docs/*.test.mjs",
     "docs:build": "node scripts/docs/build.mjs",
     "docs:verify": "node scripts/docs/verify.mjs",

package/scripts/check-host-integration.mjs

@@ -0,0 +1,336 @@
+#!/usr/bin/env node
+
+import { execFileSync, spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { mkdir, mkdtemp, readFile, readdir, rm, symlink, writeFile } from "node:fs/promises";
+import { createServer } from "node:net";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseAntigravityModelIds } from "../src/provider.js";
+
+const PROVIDER_ID = "antigravity-cli";
+const CHOICE_ID = "antigravity-cli";
+const ACTION_LABEL = "Reconnect";
+const MIN_HOST_VERSION = [2026, 7, 0];
+const COMMAND_TIMEOUT_MS = 30_000;
+const STARTUP_TIMEOUT_MS = 20_000;
+
+function fail(message) {
+  throw new Error(`Host integration check failed: ${message}`);
+}
+
+export function assertAgySession(output) {
+  const modelIds = parseAntigravityModelIds(output);
+  if (modelIds.length === 0) {
+    fail("no models were returned by a live `agy` session; run `agy models` and sign in if needed");
+  }
+  return modelIds;
+}
+
+export function assertReconnectProjection(status) {
+  const capability = status?.providerCapabilities?.find(
+    (candidate) => candidate?.provider === PROVIDER_ID,
+  );
+  if (!capability) {
+    fail(`the OpenClaw host did not publish capabilities for ${PROVIDER_ID}`);
+  }
+  if (capability.loginOptions?.length) {
+    fail("credential-only Connect is exposed for Antigravity");
+  }
+  const reconnect = capability.setupActions?.find(
+    (action) => action?.choiceId === CHOICE_ID && action?.actionLabel === ACTION_LABEL,
+  );
+  if (!reconnect) {
+    fail('the Antigravity guided-discovery action is not labeled "Reconnect"');
+  }
+  return { choiceId: reconnect.choiceId, actionLabel: reconnect.actionLabel };
+}
+
+function parseHostVersion(output) {
+  const match = String(output).match(/OpenClaw\s+(\d+)\.(\d+)\.(\d+)/u);
+  if (!match) {
+    fail(`could not parse the installed OpenClaw version from ${JSON.stringify(String(output).trim())}`);
+  }
+  return match.slice(1, 4).map(Number);
+}
+
+function compareVersions(left, right) {
+  for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+    const difference = (left[index] ?? 0) - (right[index] ?? 0);
+    if (difference !== 0) return Math.sign(difference);
+  }
+  return 0;
+}
+
+export function commandOutput(command, args, options = {}) {
+  const timeout = options.timeout ?? COMMAND_TIMEOUT_MS;
+  try {
+    return execFileSync(command, args, {
+      encoding: "utf8",
+      maxBuffer: 16 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "pipe"],
+      ...options,
+      timeout,
+    });
+  } catch (error) {
+    if (error?.code === "ETIMEDOUT") {
+      fail(`${command} timed out after ${timeout}ms`);
+    }
+    throw error;
+  }
+}
+
+function parseJsonOutput(command, args, options) {
+  const output = commandOutput(command, args, options);
+  try {
+    return JSON.parse(output);
+  } catch {
+    fail(`${command} returned non-JSON output`);
+  }
+}
+
+export function buildGatewayCallArgs(method, gatewayUrl, token, timeout = 10_000, params) {
+  const args = [
+    "gateway",
+    "call",
+    method,
+    "--url",
+    gatewayUrl,
+    "--token",
+    token,
+    "--json",
+    "--timeout",
+    String(timeout),
+  ];
+  if (params !== undefined) {
+    args.push("--params", JSON.stringify(params));
+  }
+  return args;
+}
+
+function findReconnectCandidate(detection) {
+  const candidate = detection?.candidates?.find(
+    (entry) =>
+      entry?.kind === `provider-auto:${CHOICE_ID}` &&
+      typeof entry?.modelRef === "string" &&
+      entry.modelRef.startsWith(`${PROVIDER_ID}/`),
+  );
+  if (!candidate) {
+    fail("guided discovery did not return an Antigravity Reconnect candidate");
+  }
+  return candidate;
+}
+
+function assertReconnectActivation(result, candidate) {
+  if (result?.ok !== true || result?.modelRef !== candidate.modelRef) {
+    fail(`Reconnect activation failed: ${result?.error ?? "unexpected host response"}`);
+  }
+  return { modelRef: result.modelRef, latencyMs: result.latencyMs };
+}
+
+export async function createIsolatedAgyHome(tempRoot, sourceHome = homedir()) {
+  const sourceGemini = join(sourceHome, ".gemini");
+  const isolatedHome = join(tempRoot, "home");
+  const isolatedGemini = join(isolatedHome, ".gemini");
+  await mkdir(isolatedGemini, { recursive: true });
+  for (const entry of await readdir(sourceGemini, { withFileTypes: true })) {
+    if (entry.name === "config") continue;
+    await symlink(
+      join(sourceGemini, entry.name),
+      join(isolatedGemini, entry.name),
+      entry.isDirectory() ? "dir" : "file",
+    );
+  }
+  await mkdir(join(isolatedGemini, "config"), { recursive: true });
+  return isolatedHome;
+}
+
+async function reserveLoopbackPort() {
+  const server = createServer();
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve);
+  });
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : null;
+  await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+  if (!port) fail("could not reserve a loopback port for the isolated host");
+  return port;
+}
+
+async function delay(milliseconds) {
+  await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+async function waitForGateway(openclaw, gatewayUrl, token, env, child, diagnostics) {
+  const deadline = Date.now() + STARTUP_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (child.exitCode !== null) {
+      fail(`the isolated OpenClaw gateway exited early${diagnostics()}`);
+    }
+    try {
+      parseJsonOutput(openclaw, buildGatewayCallArgs("health", gatewayUrl, token, 1_000), {
+        env,
+        timeout: 2_000,
+      });
+      return;
+    } catch {
+      await delay(250);
+    }
+  }
+  fail(`the isolated OpenClaw gateway did not become ready within ${STARTUP_TIMEOUT_MS}ms${diagnostics()}`);
+}
+
+async function stopGateway(child) {
+  if (child.exitCode !== null) return;
+  child.kill("SIGTERM");
+  await Promise.race([
+    new Promise((resolve) => child.once("exit", resolve)),
+    delay(3_000).then(() => child.kill("SIGKILL")),
+  ]);
+}
+
+function boundedDiagnostics(chunks) {
+  const text = chunks.join("").trim();
+  return text ? `\nGateway diagnostics:\n${text.slice(-4_000)}` : "";
+}
+
+export async function withTemporaryRoot(run) {
+  const tempRoot = await mkdtemp(join(tmpdir(), "antigravity-host-check-"));
+  try {
+    return await run(tempRoot);
+  } finally {
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+}
+
+export async function runHostIntegrationCheck({
+  openclaw = process.env.OPENCLAW_BIN?.trim() || "openclaw",
+  agy = process.env.AGY_BIN?.trim() || "agy",
+} = {}) {
+  const pluginRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+  const packageJson = JSON.parse(await readFile(join(pluginRoot, "package.json"), "utf8"));
+  const hostVersion = parseHostVersion(commandOutput(openclaw, ["--version"]));
+  if (compareVersions(hostVersion, MIN_HOST_VERSION) < 0) {
+    fail(`OpenClaw ${hostVersion.join(".")} is older than the required ${MIN_HOST_VERSION.join(".")}`);
+  }
+
+  const modelIds = assertAgySession(commandOutput(agy, ["models"]));
+  return await withTemporaryRoot(async (tempRoot) => {
+      const isolatedHome = await createIsolatedAgyHome(tempRoot);
+      const stateDir = join(tempRoot, "state");
+      const configPath = join(tempRoot, "openclaw.json");
+      const port = await reserveLoopbackPort();
+      const gatewayUrl = `ws://127.0.0.1:${port}`;
+      const gatewayToken = randomBytes(24).toString("hex");
+      const env = {
+        ...process.env,
+        HOME: isolatedHome,
+        USERPROFILE: isolatedHome,
+        OPENCLAW_CONFIG_PATH: configPath,
+        OPENCLAW_STATE_DIR: stateDir,
+      };
+      const gatewayOutput = [];
+      let gateway;
+
+      try {
+        await mkdir(stateDir, { recursive: true });
+        await writeFile(
+          configPath,
+          `${JSON.stringify(
+            {
+              gateway: { mode: "local", bind: "loopback", auth: { mode: "token" } },
+              plugins: {
+                allow: ["antigravity"],
+                load: { paths: [pluginRoot] },
+                entries: { antigravity: { enabled: true, config: { command: agy } } },
+              },
+            },
+            null,
+            2,
+          )}\n`,
+          { mode: 0o600 },
+        );
+
+        gateway = spawn(
+          openclaw,
+          [
+            "gateway",
+            "run",
+            "--port",
+            String(port),
+            "--bind",
+            "loopback",
+            "--auth",
+            "token",
+            "--token",
+            gatewayToken,
+            "--allow-unconfigured",
+          ],
+          { env, stdio: ["ignore", "pipe", "pipe"] },
+        );
+        gateway.stdout.on("data", (chunk) => gatewayOutput.push(String(chunk)));
+        gateway.stderr.on("data", (chunk) => gatewayOutput.push(String(chunk)));
+        const diagnostics = () => boundedDiagnostics(gatewayOutput);
+
+        await waitForGateway(openclaw, gatewayUrl, gatewayToken, env, gateway, diagnostics);
+        const status = parseJsonOutput(
+          openclaw,
+          buildGatewayCallArgs("models.authStatus", gatewayUrl, gatewayToken),
+          { env, timeout: 15_000 },
+        );
+        const action = assertReconnectProjection(status);
+        const detection = parseJsonOutput(
+          openclaw,
+          buildGatewayCallArgs("openclaw.setup.detect", gatewayUrl, gatewayToken, 30_000),
+          { env, timeout: 35_000 },
+        );
+        const candidate = findReconnectCandidate(detection);
+        const activation = assertReconnectActivation(
+          parseJsonOutput(
+            openclaw,
+            buildGatewayCallArgs(
+              "openclaw.setup.activate",
+              gatewayUrl,
+              gatewayToken,
+              120_000,
+              { kind: candidate.kind, modelRef: candidate.modelRef },
+            ),
+            { env, timeout: 125_000 },
+          ),
+          candidate,
+        );
+        return {
+          pluginVersion: packageJson.version,
+          hostVersion: hostVersion.join("."),
+          agyModelCount: modelIds.length,
+          action,
+          activation,
+        };
+      } finally {
+        if (gateway) await stopGateway(gateway);
+      }
+    });
+}
+
+const isMain = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
+if (isMain) {
+  runHostIntegrationCheck()
+    .then((result) => {
+      process.stdout.write(
+        [
+          `PASS @cavi-ai/antigravity ${result.pluginVersion}`,
+          `OpenClaw ${result.hostVersion}`,
+          `live agy models: ${result.agyModelCount}`,
+          `host action: ${result.action.actionLabel}`,
+          `Reconnect activation: ${result.activation.modelRef}`,
+          "credential-only Connect: absent",
+        ].join("\n") + "\n",
+      );
+    })
+    .catch((error) => {
+      process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+      process.exitCode = 1;
+    });
+}

package/src/cli-backend.js

@@ -15,6 +15,7 @@
 import { ANTIGRAVITY_MODEL_ALIASES } from "./models.js";
 
 export const ANTIGRAVITY_BACKEND_ID = "antigravity-cli";
+export const TOOL_FREE_SETUP_AGENT_ID = "openclaw-antigravity-setup";
 
 /** agy print mode cannot prompt a human, so tool calls need a non-review mode. */
 export const DEFAULT_MODE = "accept-edits";
@@ -44,6 +45,17 @@ export function buildAntigravityCliBackend(options = {}) {
   const base = buildBaseArgs(options);
   return {
     id: ANTIGRAVITY_BACKEND_ID,
+    runtimeArtifact: {
+      kind: "bundled-package-tree",
+      packageName: "agy",
+      entrypoint: "command",
+      nativeExecutableNames: ["agy", "agy.exe"],
+    },
+    sideQuestionToolMode: "disabled",
+    resolveExecutionArgs: ({ baseArgs, executionMode }) =>
+      executionMode === "side-question"
+        ? [...baseArgs, "--agent", TOOL_FREE_SETUP_AGENT_ID]
+        : baseArgs,
     // Standalone backend: agy's catalog (Gemini + Claude + GPT-OSS behind one
     // subscription) belongs to no existing provider, so it owns direct
     // `antigravity-cli/<model>` refs rather than aliasing a canonical provider.

package/src/index.js

@@ -7,7 +7,7 @@ export const PLUGIN_ID = "antigravity";
 export const plugin = {
   id: PLUGIN_ID,
   name: "Antigravity CLI",
-  version: "0.2.2",
+  version: "0.2.4",
   description: "Runs Google's Antigravity CLI (agy) as a subscription-backed model provider.",
   register: registerAntigravity,
 };

package/src/provider.js

@@ -1,9 +1,11 @@
 // Provider registration for Antigravity (`agy`).
 //
-// agy owns the user's Antigravity OAuth session. The custom auth method below
+// agy owns the user's Antigravity OAuth session. Guided discovery/reconnect
 // validates that CLI-owned session and records the provider's non-secret
 // connection (models, endpoint) in config; OpenClaw stores no key for this provider.
 import { execFile } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { ANTIGRAVITY_BACKEND_ID } from "./cli-backend.js";
 import {
@@ -18,6 +20,12 @@ export const ANTIGRAVITY_PROVIDER_ID = ANTIGRAVITY_BACKEND_ID;
 const execFileAsync = promisify(execFile);
 const COMMAND_TIMEOUT_MS = 15_000;
 const COMMAND_MAX_BUFFER_BYTES = 1_048_576;
+const MINIMUM_TOOL_FREE_AGY_VERSION = [1, 2, 1];
+const TOOL_FREE_SETUP_PLUGIN_ROOT = join(
+  dirname(fileURLToPath(import.meta.url)),
+  "..",
+  "agy-plugin",
+);
 
 const MISSING_AUTH_MESSAGE =
   "Antigravity CLI is not ready. Install Google's Antigravity CLI (`agy`), sign in with your Google subscription, then confirm with `agy models`. This provider stores no API key in OpenClaw.";
@@ -42,6 +50,20 @@ function isAbortError(error, signal) {
   return signal?.aborted === true || error?.name === "AbortError" || error?.code === "ABORT_ERR";
 }
 
+function supportsToolFreeSetupAgent(output) {
+  const match = /(\d+)\.(\d+)\.(\d+)/u.exec(String(output ?? ""));
+  if (!match) {
+    return false;
+  }
+  const version = match.slice(1).map(Number);
+  for (let index = 0; index < version.length; index += 1) {
+    if (version[index] !== MINIMUM_TOOL_FREE_AGY_VERSION[index]) {
+      return version[index] > MINIMUM_TOOL_FREE_AGY_VERSION[index];
+    }
+  }
+  return true;
+}
+
 /** Extracts model ids from the human-readable `agy models` table. */
 export function parseAntigravityModelIds(output) {
   const ids = [];
@@ -77,6 +99,16 @@ export function buildAntigravityProvider(options = {}, dependencies = {}) {
     return parseAntigravityModelIds(output);
   };
 
+  const installToolFreeSetupAgent = async (context) => {
+    throwIfAborted(context.signal);
+    const version = await execute(command, ["--version"], context);
+    if (!supportsToolFreeSetupAgent(version)) {
+      throw new Error("Antigravity CLI 1.2.1 or newer is required for tool-free setup checks.");
+    }
+    await execute(command, ["plugin", "install", TOOL_FREE_SETUP_PLUGIN_ROOT], context);
+    throwIfAborted(context.signal);
+  };
+
   const detect = async (context) => {
     try {
       const modelId = chooseDetectedModel(await listModels(context));
@@ -138,9 +170,9 @@ export function buildAntigravityProvider(options = {}, dependencies = {}) {
           detectAvailability: async (context) => {
             try {
               throwIfAborted(context.signal);
-              await execute(command, ["--version"], context);
+              const version = await execute(command, ["--version"], context);
               throwIfAborted(context.signal);
-              return true;
+              return supportsToolFreeSetupAgent(version);
             } catch (error) {
               if (isAbortError(error, context.signal)) {
                 throw error;
@@ -156,6 +188,7 @@ export function buildAntigravityProvider(options = {}, dependencies = {}) {
             }
             const modelId = context.modelRef.slice(prefix.length);
             try {
+              await installToolFreeSetupAgent(context);
               const available = await listModels(context);
               return available.includes(modelId)
                 ? validatedResult(context.modelRef, context.config)
@@ -169,6 +202,14 @@ export function buildAntigravityProvider(options = {}, dependencies = {}) {
           },
         },
         run: async (context) => {
+          try {
+            await installToolFreeSetupAgent(context);
+          } catch (error) {
+            if (isAbortError(error, context.signal)) {
+              throw error;
+            }
+            throw new Error(RECONNECT_ERROR_MESSAGE);
+          }
           const detected = await detect(context);
           if (!detected) {
             throw new Error(RECONNECT_ERROR_MESSAGE);