@cavi-ai/antigravity 0.2.3 → 0.2.4

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # 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

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:
 
@@ -40,7 +40,10 @@ Restart the OpenClaw Gateway after installation.
 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.
+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
 
@@ -124,11 +127,13 @@ npm run check:host-integration # live agy + isolated installed-host Reconnect ch
 
 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, verifies that the host
-projects **Reconnect** for Antigravity, and verifies that credential-only
-**Connect** is absent. The temporary gateway and state are removed afterward;
-the installed gateway, OpenClaw config, credentials, and default model are not
-changed. Set `AGY_BIN` or `OPENCLAW_BIN` to use a non-default executable.
+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

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.3",
+  "version": "0.2.4",
   "description": "Runs Google's Antigravity CLI (agy) as a subscription-backed model provider.",
   "enabledByDefault": false,
   "activation": {

package/package.json

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

package/scripts/check-host-integration.mjs

@@ -2,9 +2,9 @@
 
 import { execFileSync, spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, readdir, rm, symlink, writeFile } from "node:fs/promises";
 import { createServer } from "node:net";
-import { tmpdir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseAntigravityModelIds } from "../src/provider.js";
@@ -90,8 +90,8 @@ function parseJsonOutput(command, args, options) {
   }
 }
 
-export function buildGatewayCallArgs(method, gatewayUrl, token, timeout = 10_000) {
-  return [
+export function buildGatewayCallArgs(method, gatewayUrl, token, timeout = 10_000, params) {
+  const args = [
     "gateway",
     "call",
     method,
@@ -103,6 +103,47 @@ export function buildGatewayCallArgs(method, gatewayUrl, token, timeout = 10_000
     "--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() {
@@ -177,77 +218,100 @@ export async function runHostIntegrationCheck({
 
   const modelIds = assertAgySession(commandOutput(agy, ["models"]));
   return await withTemporaryRoot(async (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,
-      OPENCLAW_CONFIG_PATH: configPath,
-      OPENCLAW_CONFIG_READONLY: "1",
-      OPENCLAW_STATE_DIR: stateDir,
-    };
-    const gatewayOutput = [];
-    let gateway;
+      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 } } },
+      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 },
-      );
+            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);
+        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);
-      return {
-        pluginVersion: packageJson.version,
-        hostVersion: hostVersion.join("."),
-        agyModelCount: modelIds.length,
-        action,
-      };
-    } finally {
-      if (gateway) await stopGateway(gateway);
-    }
-  });
+        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];
@@ -260,6 +324,7 @@ if (isMain) {
           `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",
       );

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.3",
+  version: "0.2.4",
   description: "Runs Google's Antigravity CLI (agy) as a subscription-backed model provider.",
   register: registerAntigravity,
 };

package/src/provider.js

@@ -4,6 +4,8 @@
 // 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);