@agentex/agent 0.0.37 → 0.0.39

package/src/providers/antigravity/connection.ts

@@ -0,0 +1,304 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import type { StreamEvent } from "../../types.js";
+import { killProcessTree } from "../../utils/process.js";
+import {
+  ANTIGRAVITY_PROVIDER_TYPE,
+  isAgyAuthRequired,
+  parseAgyErrorLine,
+  type AgyErrorReport,
+  type AgyResult,
+  type AgyStreamParser,
+} from "./parse.js";
+import { AGY_LOGIN_COMMAND } from "./runtime.js";
+
+const STDERR_TAIL_BYTES = 16 * 1024;
+
+export interface AgyConnectionOptions {
+  command: string;
+  args: string[];
+  cwd: string;
+  env: Record<string, string>;
+  parser: AgyStreamParser;
+  onEvent?: (event: StreamEvent) => void | Promise<void>;
+  onOutput?: (stream: "stdout" | "stderr", chunk: string) => void | Promise<void>;
+}
+
+/** How a turn (or the whole process) ended, as seen by the host. */
+export interface AgyTurnOutcome {
+  /** The turn's `result` event, or null when the process exited first. */
+  result: AgyResult | null;
+  /** The process has exited. */
+  exited: boolean;
+  exitCode: number | null;
+  signal: string | null;
+  /** The CLI asked for a sign-in, which a headless run can never complete. */
+  authRequired: boolean;
+  agyError: AgyErrorReport | null;
+  /** Last ~16KB of stderr, for error messages. */
+  stderr: string;
+}
+
+/**
+ * One headless `agy` process speaking `stream-json` in both directions.
+ *
+ * Every stdout line is parsed and dispatched through a single promise chain,
+ * so `onEvent` handlers run strictly in wire order and a turn's waiter
+ * resolves only after the handler for its `result` event has settled.
+ */
+export class AgyConnection {
+  readonly pid: number | null;
+  authRequired = false;
+  agyError: AgyErrorReport | null = null;
+
+  private readonly child: ChildProcess;
+  private chain: Promise<void> = Promise.resolve();
+  private stdoutBuffer = "";
+  private stderrLineBuffer = "";
+  private stderrTail = "";
+  private exitInfo: { code: number | null; signal: string | null } | null = null;
+  private finalized = false;
+  private readonly waiters: Array<(outcome: AgyTurnOutcome) => void> = [];
+  private readonly exitWaiters: Array<() => void> = [];
+
+  constructor(private readonly options: AgyConnectionOptions) {
+    this.child = spawn(options.command, options.args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: false,
+      // A process group lets interrupt/terminate reach the commands agy runs.
+      detached: process.platform !== "win32",
+    });
+    this.pid = this.child.pid ?? null;
+
+    this.child.stdin?.on("error", () => { /* agy exited; the exit path reports it */ });
+    this.child.stdout?.setEncoding("utf-8");
+    this.child.stderr?.setEncoding("utf-8");
+    this.child.stdout?.on("data", (chunk: string) => this.onStdout(chunk));
+    this.child.stderr?.on("data", (chunk: string) => this.onStderr(chunk));
+    this.child.on("error", (err) => {
+      this.appendStderrTail(`${err.message}\n`);
+      this.finalize(null, null);
+    });
+    this.child.on("close", (code, signal) => this.finalize(code, signal ?? null));
+  }
+
+  get alive(): boolean {
+    return this.exitInfo === null;
+  }
+
+  /** Exit status, or null while the process runs. */
+  get exit(): { code: number | null; signal: string | null } | null {
+    return this.exitInfo;
+  }
+
+  /** Last ~16KB of stderr. */
+  get stderr(): string {
+    return this.stderrTail;
+  }
+
+  /** Resolves once the process has exited and every queued event was dispatched. */
+  exited(): Promise<void> {
+    if (this.finalized) return this.chain;
+    return new Promise((resolve) => this.exitWaiters.push(resolve));
+  }
+
+  /** Send one user message. Resolve it with `nextTurn()`. */
+  write(text: string): void {
+    if (!this.alive || !this.child.stdin || this.child.stdin.destroyed) return;
+    this.child.stdin.write(`${JSON.stringify({ event: "user", message: { content: text } })}\n`);
+  }
+
+  /** Close stdin. `agy` finishes the current turn and exits. */
+  endInput(): void {
+    try {
+      this.child.stdin?.end();
+    } catch {
+      /* already closed */
+    }
+  }
+
+  /** Resolves with the next `result` event, or with the exit when no result comes. */
+  nextTurn(): Promise<AgyTurnOutcome> {
+    if (this.finalized) return Promise.resolve(this.outcome(null));
+    return new Promise((resolve) => this.waiters.push(resolve));
+  }
+
+  /** Signal the whole process group. */
+  signal(signal: NodeJS.Signals): void {
+    if (this.pid != null && this.alive) killProcessTree(this.pid, signal);
+  }
+
+  /** True when the process exited within `ms`. */
+  async waitForExit(ms: number): Promise<boolean> {
+    return (await within(this.exited().then(() => true), ms)) === true;
+  }
+
+  /**
+   * Stop the process: close stdin and give it a moment to exit on its own
+   * (an idle `agy` flushes its conversation history and exits), then
+   * SIGTERM, then SIGKILL after `graceSec`.
+   */
+  async terminate(graceSec = 5, idleWaitMs = 1000): Promise<void> {
+    if (this.finalized) return;
+    this.endInput();
+    if (idleWaitMs > 0 && await this.waitForExit(idleWaitMs)) return;
+    this.signal("SIGTERM");
+    if (await this.waitForExit(graceSec * 1000)) return;
+    this.signal("SIGKILL");
+    await this.waitForExit(1000);
+  }
+
+  private onStdout(chunk: string): void {
+    this.stdoutBuffer += chunk;
+    const lines = this.stdoutBuffer.split("\n");
+    this.stdoutBuffer = lines.pop() ?? "";
+    for (const line of lines) this.enqueueLine(line);
+  }
+
+  private enqueueLine(rawLine: string): void {
+    const line = rawLine.replace(/\r$/, "");
+    if (!line.trim()) return;
+    this.chain = this.chain.then(async () => {
+      await this.emitOutput("stdout", `${line}\n`);
+      const parsed = this.options.parser.parseLine(line);
+      for (const event of parsed.events) await this.emitEvent(event);
+      if (parsed.result) this.waiters.shift()?.(this.outcome(parsed.result));
+    });
+  }
+
+  private onStderr(chunk: string): void {
+    this.appendStderrTail(chunk);
+    this.chain = this.chain.then(() => this.emitOutput("stderr", chunk));
+    this.stderrLineBuffer += chunk;
+    const lines = this.stderrLineBuffer.split("\n");
+    this.stderrLineBuffer = lines.pop() ?? "";
+    for (const line of lines) this.inspectStderrLine(line);
+    // The sign-in prompt can sit on an unterminated line while agy waits.
+    if (!this.authRequired && isAgyAuthRequired(this.stderrLineBuffer)) this.onAuthRequired(this.stderrLineBuffer);
+  }
+
+  private inspectStderrLine(line: string): void {
+    const report = parseAgyErrorLine(line);
+    if (report) this.agyError = report;
+    if (!this.authRequired && isAgyAuthRequired(line)) this.onAuthRequired(line);
+  }
+
+  /**
+   * A headless run without a cached sign-in prints a login URL and waits a
+   * full minute for a code nobody can paste. Fail fast instead: report it
+   * and stop the process.
+   */
+  private onAuthRequired(message: string): void {
+    this.authRequired = true;
+    const event: StreamEvent = {
+      type: "auth_required",
+      httpStatus: null,
+      reason: "missing",
+      loginCommand: AGY_LOGIN_COMMAND,
+      message: message.trim() || "Antigravity CLI requires sign-in.",
+      timestamp: new Date().toISOString(),
+      providerType: ANTIGRAVITY_PROVIDER_TYPE,
+      sessionId: this.options.parser.conversationId,
+      messageId: null,
+      eventId: null,
+      turnId: null,
+      parentToolCallId: null,
+      raw: { stderr: message },
+    };
+    this.chain = this.chain.then(() => this.emitEvent(event));
+    this.signal("SIGTERM");
+  }
+
+  private appendStderrTail(chunk: string): void {
+    this.stderrTail = (this.stderrTail + chunk).slice(-STDERR_TAIL_BYTES);
+  }
+
+  private finalize(code: number | null, signal: string | null): void {
+    if (this.exitInfo === null) this.exitInfo = { code, signal };
+    if (this.finalized) return;
+    this.finalized = true;
+    if (this.stdoutBuffer.trim()) this.enqueueLine(this.stdoutBuffer);
+    this.stdoutBuffer = "";
+    if (this.stderrLineBuffer.trim()) this.inspectStderrLine(this.stderrLineBuffer);
+    this.stderrLineBuffer = "";
+    this.chain = this.chain.then(() => {
+      for (const waiter of this.waiters.splice(0)) waiter(this.outcome(null));
+      for (const waiter of this.exitWaiters.splice(0)) waiter();
+    });
+  }
+
+  private outcome(result: AgyResult | null): AgyTurnOutcome {
+    return {
+      result,
+      exited: this.exitInfo !== null,
+      exitCode: this.exitInfo?.code ?? null,
+      signal: this.exitInfo?.signal ?? null,
+      authRequired: this.authRequired,
+      agyError: this.agyError,
+      stderr: this.stderrTail,
+    };
+  }
+
+  private async emitEvent(event: StreamEvent): Promise<void> {
+    if (!this.options.onEvent) return;
+    try {
+      await this.options.onEvent(event);
+    } catch {
+      /* a throwing handler must not break the stream */
+    }
+  }
+
+  private async emitOutput(stream: "stdout" | "stderr", chunk: string): Promise<void> {
+    if (!this.options.onOutput) return;
+    try {
+      await this.options.onOutput(stream, chunk);
+    } catch {
+      /* swallow */
+    }
+  }
+}
+
+/** First meaningful stderr line, skipping the sign-in URL noise. */
+export function firstAgyErrorLine(stderr: string): string | null {
+  for (const raw of stderr.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || /^https?:\/\//.test(line) || line.startsWith("AGY_ERROR:")) continue;
+    return line.replace(/^error:\s*/i, "");
+  }
+  return null;
+}
+
+/** Waits for `promise` up to `ms`; resolves null on timeout. */
+export function within<T>(promise: Promise<T>, ms: number): Promise<T | null> {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(null), ms);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      () => {
+        clearTimeout(timer);
+        resolve(null);
+      },
+    );
+  });
+}
+
+/**
+ * Interrupt the running turn like Ctrl+C would: SIGINT the process group,
+ * give agy a moment to report the turn as INTERRUPTED, and stop the process
+ * if it does not. Resolves with whatever outcome arrived.
+ */
+export async function interruptAgyTurn(
+  connection: AgyConnection,
+  pending: Promise<AgyTurnOutcome>,
+  graceSec = 5,
+): Promise<AgyTurnOutcome | null> {
+  connection.signal("SIGINT");
+  const settled = await within(pending, 3000);
+  if (settled) return settled;
+  await connection.terminate(graceSec, 0);
+  return within(pending, 2000);
+}

package/src/providers/antigravity/discovery.ts

@@ -0,0 +1,90 @@
+import type { AgentMode, ListModelsOptions, ListModesOptions, ProviderModel } from "../../types.js";
+import { buildEnv, ensurePathInEnv } from "../../utils/env.js";
+import { withModelCache } from "../../utils/model-cache.js";
+import { runChildProcess } from "../../utils/process.js";
+import { isAgyAuthRequired } from "./parse.js";
+import { ANTIGRAVITY_MODES, AGY_SIGN_IN_MESSAGE, findAgyBinary } from "./runtime.js";
+
+function rec(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+
+function fromJson(output: string): ProviderModel[] | null {
+  try {
+    const parsed = JSON.parse(output) as unknown;
+    const list = Array.isArray(parsed) ? parsed : rec(parsed)["models"];
+    if (!Array.isArray(list)) return null;
+    return list.map((value) => {
+      if (typeof value === "string") return { id: value, name: value };
+      const model = rec(value);
+      const id = [model["slug"], model["id"], model["model"]].find((v): v is string => typeof v === "string" && v.length > 0) ?? "";
+      const name = [model["display_name"], model["displayName"], model["name"], model["label"]]
+        .find((v): v is string => typeof v === "string" && v.length > 0);
+      return { id, name: name ?? id };
+    }).filter((model) => model.id);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Parse `agy models`. The JSON form is preferred when a build supports it;
+ * the text form is one model per line: a slug, two or more spaces, then the
+ * display name, for example `gemini-3.1-pro-high     Gemini 3.1 Pro (High)`.
+ */
+export function parseAntigravityModels(output: string): ProviderModel[] {
+  const trimmed = output.trim();
+  if (!trimmed) return [];
+  const json = trimmed.startsWith("{") || trimmed.startsWith("[") ? fromJson(trimmed) : null;
+  if (json?.length) return json;
+
+  const seen = new Set<string>();
+  const models: ProviderModel[] = [];
+  for (const raw of trimmed.split(/\r?\n/)) {
+    const line = raw.replace(/^\s*(?:[*•>-]|→)\s*/, "").trim();
+    if (!line || /^(?:available\s+)?models?:?$/i.test(line) || /^fetching\b/i.test(line) || line === "...") continue;
+    const match = line.match(/^([A-Za-z0-9][\w./:-]*)(?:\s{2,}|\t+)(.+)$/) ?? line.match(/^([A-Za-z0-9][\w./:-]*)$/);
+    const id = match?.[1];
+    if (!id || seen.has(id) || /^(?:error|warning|usage)$/i.test(id)) continue;
+    seen.add(id);
+    const name = match?.[2]?.replace(/\s*\((?:current|default|selected)\)\s*$/i, "").trim();
+    models.push({ id, name: name || id });
+  }
+  return models;
+}
+
+export async function listAntigravityModels(options: ListModelsOptions = {}): Promise<ProviderModel[]> {
+  return withModelCache("antigravity", options, options.cacheTtlMs, () => discoverAntigravityModels(options));
+}
+
+async function discoverAntigravityModels(options: ListModelsOptions): Promise<ProviderModel[]> {
+  const resolved = await findAgyBinary(options);
+  const env = buildEnv(options.env);
+  ensurePathInEnv(env);
+  const cwd = options.cwd ?? process.cwd();
+  let lastOutput = "";
+  for (const args of [["models", "--output-format", "json"], ["models"]]) {
+    const result = await runChildProcess({
+      runId: "antigravity-model-discovery",
+      command: resolved.bin,
+      args: [...resolved.prefixArgs, ...args],
+      cwd,
+      env,
+      timeoutSec: 20,
+    });
+    lastOutput = `${result.stdout}\n${result.stderr}`;
+    if (isAgyAuthRequired(lastOutput)) {
+      throw new Error(AGY_SIGN_IN_MESSAGE);
+    }
+    if (result.exitCode !== 0) continue;
+    const models = parseAntigravityModels(result.stdout);
+    if (models.length) return models;
+  }
+  const detail = lastOutput.split(/\r?\n/).map((line) => line.trim()).find((line) => /error/i.test(line));
+  throw new Error(detail ?? "The installed Antigravity CLI did not list any models");
+}
+
+/** Antigravity's modes are a fixed set (`--mode`); listing them spawns nothing. */
+export async function listAntigravityModes(_options: ListModesOptions = {}): Promise<AgentMode[]> {
+  return ANTIGRAVITY_MODES.map((mode) => ({ ...mode }));
+}

package/src/providers/antigravity/execute.ts

@@ -0,0 +1,214 @@
+import type { ExecutionContext, ExecutionResult, ExecutionStatus, StreamEvent } from "../../types.js";
+import { detectAuth } from "../../utils/auth.js";
+import { buildEnv, ensurePathInEnv } from "../../utils/env.js";
+import { resolveInstructions } from "../../utils/instructions.js";
+import { injectHomeSkills } from "../../utils/skills.js";
+import { uuidv7 } from "../../utils/uuid.js";
+import { prepareWorkspace, type PreparedWorkspace } from "../../utils/workspace.js";
+import { AgyConnection, firstAgyErrorLine, interruptAgyTurn, type AgyTurnOutcome } from "./connection.js";
+import {
+  AgyStreamParser,
+  agyUsageRecord,
+  classifyAgyFailure,
+  mapAgyExecutionStatus,
+} from "./parse.js";
+import { AGY_SIGN_IN_MESSAGE, buildAgyArgs, findAgyBinary, readAgyResumeId } from "./runtime.js";
+
+/**
+ * One-shot Antigravity run: start `agy` in stream-json mode, write the prompt
+ * as a single NDJSON message, close stdin, and wait for the process to exit.
+ * The prompt travels over stdin, so it is never size-limited by argv or
+ * visible in `ps`.
+ */
+export async function executeAntigravityProvider(ctx: ExecutionContext): Promise<ExecutionResult> {
+  const runId = ctx.runId ?? uuidv7();
+  const startedAt = new Date().toISOString();
+  const startMs = Date.now();
+  const config = ctx.config ?? {};
+  const requestedModel = ctx.model ?? config.model ?? null;
+  let cwd = ctx.cwd ?? process.cwd();
+
+  const finish = (fields: Partial<ExecutionResult> & Pick<ExecutionResult, "status">): ExecutionResult => ({
+    runId,
+    exitCode: null,
+    signal: null,
+    startedAt,
+    completedAt: new Date().toISOString(),
+    durationMs: Date.now() - startMs,
+    errorMessage: null,
+    errorCode: null,
+    costUsd: null,
+    model: requestedModel,
+    summary: null,
+    sessionParams: null,
+    sessionDisplayId: null,
+    clearSession: false,
+    billingType: null,
+    ...fields,
+  });
+
+  ctx.onLifecycle?.({ phase: "preparing", step: "binary" });
+  let binary;
+  try {
+    binary = await findAgyBinary({ cwd, ...(ctx.env ? { env: ctx.env } : {}), config });
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : "Antigravity CLI (agy) not found";
+    ctx.onLifecycle?.({ phase: "error", message: errorMessage });
+    return finish({ status: "failed", errorMessage, errorCode: "binary_not_found", model: null });
+  }
+
+  let workspace: PreparedWorkspace | undefined;
+  if (config.workspace) {
+    ctx.onLifecycle?.({ phase: "preparing", step: "workspace" });
+    workspace = await prepareWorkspace(cwd, config.workspace);
+    cwd = workspace.cwd;
+  }
+
+  ctx.onLifecycle?.({ phase: "preparing", step: "auth" });
+  const env = buildEnv(ctx.env);
+  ensurePathInEnv(env);
+  const billingType = detectAuth("antigravity", env).billingType;
+
+  const resumeId = readAgyResumeId(ctx.sessionParams, cwd);
+
+  ctx.onLifecycle?.({ phase: "preparing", step: "instructions" });
+  // A resumed conversation already carries its instructions.
+  const instructions = resumeId ? null : await resolveInstructions(config.instructionsFile);
+  const prompt = instructions ? `${instructions}\n\n${ctx.prompt}` : ctx.prompt;
+
+  if (config.skillDirs && config.skillDirs.length > 0) {
+    ctx.onLifecycle?.({ phase: "preparing", step: "skills" });
+    try {
+      await injectHomeSkills(config.skillDirs, "antigravity");
+    } catch {
+      // Non-fatal
+    }
+  }
+
+  const parser = new AgyStreamParser({
+    includePartialMessages: config.includePartialMessages,
+    conversationId: resumeId,
+  });
+  const assistantText: string[] = [];
+  const onEvent = async (event: StreamEvent): Promise<void> => {
+    if (event.type === "assistant") assistantText.push(event.text);
+    await ctx.onEvent?.(event);
+  };
+
+  ctx.onLifecycle?.({ phase: "spawning" });
+  const connection = new AgyConnection({
+    command: binary.bin,
+    args: [...binary.prefixArgs, ...buildAgyArgs(config, { resumeId, model: requestedModel })],
+    cwd,
+    env,
+    parser,
+    onEvent,
+    ...(ctx.onOutput ? { onOutput: ctx.onOutput } : {}),
+  });
+  if (connection.pid != null) {
+    ctx.onLifecycle?.({ phase: "running", pid: connection.pid });
+    ctx.onStart?.(connection.pid);
+  }
+
+  const pending = connection.nextTurn();
+  connection.write(prompt);
+  connection.endInput();
+
+  // Guards cover the whole run, including agy finishing background work
+  // after it delivers the answer.
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  const guards: Promise<"timeout" | "aborted">[] = [];
+  if (config.timeoutSec && config.timeoutSec > 0) {
+    guards.push(new Promise((resolve) => { timer = setTimeout(() => resolve("timeout"), config.timeoutSec! * 1000); }));
+  }
+  let onAbort: (() => void) | null = null;
+  if (ctx.signal) {
+    const signal = ctx.signal;
+    guards.push(new Promise((resolve) => {
+      if (signal.aborted) resolve("aborted");
+      onAbort = () => resolve("aborted");
+      signal.addEventListener("abort", onAbort, { once: true });
+    }));
+  }
+
+  let stopped: "timeout" | "aborted" | null = null;
+  let outcome: AgyTurnOutcome | null;
+  const first = await Promise.race([pending, ...guards]);
+  if (first === "timeout" || first === "aborted") {
+    stopped = first;
+    outcome = await interruptAgyTurn(connection, pending, config.graceSec);
+    // The run is over either way; never leave the process behind.
+    await connection.terminate(config.graceSec);
+  } else {
+    outcome = first;
+    if (!outcome.exited) {
+      const ended = await Promise.race([connection.exited().then(() => "exited" as const), ...guards]);
+      if (ended !== "exited") await connection.terminate(config.graceSec, 0);
+    }
+  }
+  if (timer) clearTimeout(timer);
+  if (onAbort && ctx.signal) ctx.signal.removeEventListener("abort", onAbort);
+  // Exit status is final only once the process has gone.
+  await connection.waitForExit(1000);
+
+  const result = outcome?.result ?? null;
+  const authRequired = connection.authRequired;
+  const agyError = connection.agyError;
+  const stderr = connection.stderr;
+  const exitCode = connection.exit?.code ?? null;
+  const exitSignal = connection.exit?.signal ?? null;
+
+  let status: ExecutionStatus;
+  let errorCode: string | null = null;
+  let errorMessage: string | null = null;
+  if (stopped) {
+    status = stopped;
+    errorCode = stopped;
+    errorMessage = stopped === "timeout" ? `Timed out after ${config.timeoutSec ?? 0}s` : "Run aborted";
+  } else if (result) {
+    status = mapAgyExecutionStatus(result.status);
+    if (status !== "completed") {
+      errorCode = status === "aborted" ? "aborted" : authRequired ? "auth_required" : classifyAgyFailure(result, agyError);
+      errorMessage = errorCode === "auth_required"
+        ? AGY_SIGN_IN_MESSAGE
+        : result.error ?? agyError?.message ?? `Antigravity run ended with ${result.status}`;
+    }
+  } else if (authRequired) {
+    status = "failed";
+    errorCode = "auth_required";
+    errorMessage = AGY_SIGN_IN_MESSAGE;
+  } else {
+    status = "failed";
+    errorCode = exitCode === 0 ? "incomplete_turn" : "agent_error";
+    errorMessage = agyError?.message
+      ?? firstAgyErrorLine(stderr)
+      ?? `Antigravity CLI exited with code ${exitCode ?? "null"} without a result`;
+  }
+
+  if (status === "completed") ctx.onLifecycle?.({ phase: "completed" });
+  else if (status === "aborted") ctx.onLifecycle?.({ phase: "cancelled" });
+  else ctx.onLifecycle?.({ phase: "error", message: errorMessage ?? "Unknown error" });
+
+  const conversationId = parser.conversationId;
+  const model = parser.model ?? requestedModel;
+  const usage = agyUsageRecord(result?.turnUsage ?? null, model);
+  return finish({
+    exitCode,
+    signal: exitSignal,
+    status,
+    errorMessage,
+    errorCode,
+    ...(usage ? { usage } : {}),
+    model,
+    summary: result?.response.trim() || assistantText.join("\n\n").trim() || null,
+    sessionParams: conversationId ? { sessionId: conversationId, cwd } : null,
+    sessionDisplayId: conversationId,
+    // A --conversation id agy could not find starts a new conversation.
+    clearSession: Boolean(resumeId && conversationId && conversationId !== resumeId),
+    billingType,
+    numTurns: result?.numTurns ?? null,
+    ...(result?.deniedActions?.length ? { permissionDenials: result.deniedActions } : {}),
+    raw: result?.raw ?? null,
+    ...(workspace ? { workspace } : {}),
+  });
+}

package/src/providers/antigravity/index.ts

@@ -0,0 +1,48 @@
+import type { AgentSession, ProviderModule, SessionContext } from "../../types.js";
+import { resolveAuthForProvider } from "../../utils/auth.js";
+import { antigravitySessionCodec } from "./codec.js";
+
+/**
+ * Google Antigravity CLI (`agy`), the successor to Gemini CLI for Google
+ * accounts (Free, AI Pro, AI Ultra) since Gemini CLI stopped serving them on
+ * 2026-06-18. Driven through its headless `stream-json` mode, which keeps one
+ * process per session and resumes conversations with `--conversation`.
+ *
+ * Install: `curl -fsSL https://antigravity.google/cli/install.sh | bash`,
+ * then run `agy` once to sign in. Headless runs reuse the cached sign-in.
+ */
+export const antigravityProvider: ProviderModule = {
+  type: "antigravity",
+  capabilities: {
+    sessions: true,
+    modelDiscovery: true,
+    quotaProbing: false,
+    mcp: false,
+    skills: true,
+    instructions: true,
+    workspace: true,
+    planMode: true,
+    concurrentSend: false,
+    cancelQueuedMessage: false,
+    stopTask: false,
+    modes: true,
+    resume: true,
+    modelVariants: false,
+    permissionRequests: false,
+    questionRequests: false,
+    upstreamProviderDisconnect: false,
+    sessionModelChange: false,
+    sessionVariantChange: false,
+    sessionEffortChange: false,
+    sessionModeChange: false,
+  },
+  // Everything below loads lazily on first use.
+  execute: async (ctx) => (await import("./execute.js")).executeAntigravityProvider(ctx),
+  createSession: async (ctx: SessionContext): Promise<AgentSession> =>
+    (await import("./session.js")).createAntigravitySession(ctx),
+  resolveAuth: (ctx) => resolveAuthForProvider("antigravity", ctx),
+  sessionCodec: antigravitySessionCodec,
+  listModels: (options) => import("./discovery.js").then((m) => m.listAntigravityModels(options)),
+  listModes: (options) => import("./discovery.js").then((m) => m.listAntigravityModes(options)),
+  probeCapabilities: (ctx) => import("./probe.js").then((m) => m.probeAntigravityCapabilities(ctx)),
+};