@mrclrchtr/supi-antigravity 6.4.0 → 7.0.1

package/README.md

@@ -16,14 +16,14 @@ Run `/reload` after installation.
 
 The package never uses the normal Antigravity profile. It creates an Isolated Antigravity Home under the Pi agent directory and a stable empty Consultation Workspace.
 
-Before the tool can appear, Pi shows a command like this:
+After Pi starts, the package checks availability without making startup wait. The footer shows a spinning icon while the check runs. The tool appears only after the check is complete. When it is ready, the footer settles on the terminal-safe `✦` icon. With the SuPi footer, it appears on the stats line as `| ✦`. Before the tool can appear, Pi shows a command like this:
 
 ```bash
 cd "<consultation-workspace>" &&
 HOME="<isolated-home>" AGY_CLI_DISABLE_AUTO_UPDATE=true agy
 ```
 
-On macOS, the package also creates and unlocks a private keychain inside the Isolated Antigravity Home. This avoids the macOS warning about a missing default keychain without prompting for the normal keychain password. Run the command, sign in, exit Antigravity, and reload Pi. The installed `agy` version must be at least `1.1.24`.
+On macOS, the package also creates and unlocks a private keychain inside the Isolated Antigravity Home. This avoids the macOS warning about a missing default keychain without prompting for the normal keychain password. Run the command, sign in, exit Antigravity, and reload Pi. The installed `agy` version must be at least `1.1.24`. The availability check can still be running when Pi becomes ready.
 
 If macOS displays `antigravity.` in the warning, the final `.` is sentence punctuation. It is not part of a keychain name.
 

package/node_modules/@mrclrchtr/supi-core/README.md

@@ -21,6 +21,7 @@ pnpm add @mrclrchtr/supi-core
 ## Package surfaces
 
 - `@mrclrchtr/supi-core/api` — reusable helpers for other packages and extensions
+- `@mrclrchtr/supi-core/llm` — PI-owned direct model requests and JSON helpers
 - `@mrclrchtr/supi-core/report` — shared text/report rendering helpers for TUI and plain-text summaries
 
 ## What you get from the API
@@ -48,6 +49,13 @@ Config file locations:
 
 - `wrapExtensionContext()` — wrap injected text in SuPi's `<extension-context>` tag
 
+### Model requests
+
+- `completeModelRequest(ctx, model, context, options)` — complete through PI's model registry with stable feature affinity. PI owns auth and endpoint resolution.
+- `callWithJsonResponse()` — retry a registry request, extract JSON, and validate it with TypeBox.
+
+`completeModelRequest()` requires a stable `affinityScope`. It keeps cache retention defaults, does not include prompt content in the affinity ID, and adds OpenCode headers only when the provider or exact model endpoint matches OpenCode. Pass `maxTokens: model.maxTokens` when a caller needs the model's declared output cap without using PI private modules.
+
 ### Shared registries
 
 - context-provider registry for `/supi-context`

package/node_modules/@mrclrchtr/supi-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-core",
-  "version": "6.4.0",
+  "version": "7.0.1",
   "description": "Shared settings, configuration, reporting, and session infrastructure",
   "license": "MIT",
   "repository": {
@@ -48,10 +48,6 @@
       "optional": true
     }
   },
-  "devDependencies": {
-    "@types/node": "25.9.5",
-    "vitest": "4.1.11"
-  },
   "main": "src/api.ts",
   "exports": {
     "./api": "./src/api.ts",

package/node_modules/@mrclrchtr/supi-core/src/footer-registry.ts

@@ -2,17 +2,24 @@
 //
 // Extensions register pre-styled text chunks with a placement hint
 // ("stats" for the metrics line, "status" for the extension status line).
-// The custom footer in supi-extras (or PI's built-in footer) reads these
-// contributions and renders them alongside the built-in metrics.
+// The custom footer in supi-extras reads these contributions and renders them
+// alongside the built-in metrics. Extensions can use PI's status API as a
+// fallback when the custom footer is not installed.
 
 import { createRegistry } from "./registry-utils.ts";
 
+/** Event emitted when a dynamic footer contribution needs a new render. */
+export const FOOTER_INVALIDATE_EVENT = "supi:footer:invalidate";
+
 /** Where the contribution should appear in the footer. */
 export type FooterPlacement = "stats" | "stats-end" | "status";
 
 /** A single footer contribution registered by an extension. */
 export interface FooterContribution {
-  /** Unique key for this contribution. Re-registering with the same key replaces it. */
+  /**
+   * Unique key for this contribution. Re-registering with the same key replaces it.
+   * A same-key Pi status is treated as this contribution's built-in-footer fallback.
+   */
   key: string;
   /** Which footer line this belongs on. */
   placement: FooterPlacement;

package/node_modules/@mrclrchtr/supi-core/src/index.ts

@@ -15,6 +15,8 @@ export * from "./debug.ts";
 // biome-ignore lint/performance/noReExportAll: intentional convenience barrel
 export * from "./footer-registry.ts";
 // biome-ignore lint/performance/noReExportAll: intentional convenience barrel
+export * from "./llm.ts";
+// biome-ignore lint/performance/noReExportAll: intentional convenience barrel
 export * from "./model-selection.ts";
 // biome-ignore lint/performance/noReExportAll: intentional convenience barrel
 export * from "./path.ts";

package/node_modules/@mrclrchtr/supi-core/src/llm.ts

@@ -1,12 +1,131 @@
-import { complete } from "@earendil-works/pi-ai/compat";
+import { createHash } from "node:crypto";
+import type {
+  Api,
+  AssistantMessage,
+  Context,
+  Model,
+  ModelsApiStreamOptions,
+  ProviderHeaders,
+} from "@earendil-works/pi-ai";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { TSchema } from "typebox";
 import { Value } from "typebox/value";
 
 // Shared LLM utilities for SuPi extensions.
 //
-// Provides retry logic, structured LLM call helpers, and other
-// common patterns for extensions that interact with AI models.
+// Provides PI-owned model requests, retry logic, structured LLM call helpers,
+// and other common patterns for extensions that interact with AI models.
+
+const MODEL_REQUEST_NAMESPACE = "supi-direct-model-request-v1";
+
+/**
+ * Options for {@link completeModelRequest}.
+ *
+ * Authentication, provider environment, and session identity stay under PI
+ * control. The feature supplies a stable scope for its prompt stream.
+ */
+export type CompleteModelRequestOptions<TApi extends Api = Api> = Omit<
+  ModelsApiStreamOptions<TApi>,
+  "apiKey" | "env" | "sessionId"
+> & {
+  /** Stable feature scope. Do not include prompt, turn, or retry data. */
+  affinityScope: string;
+  /** PI owns these fields, including for APIs with open-ended option types. */
+  apiKey?: never;
+  env?: never;
+  sessionId?: never;
+};
+
+function createModelRequestAffinityId(
+  sessionId: string,
+  affinityScope: string,
+  model: Model<Api>,
+): string {
+  const material = JSON.stringify([
+    MODEL_REQUEST_NAMESPACE,
+    sessionId,
+    affinityScope,
+    model.provider,
+    model.id,
+  ]);
+  const digest = createHash("sha256").update(material, "utf8").digest("hex");
+  return `supi-${digest.slice(0, 56)}`;
+}
+
+function isOpenCodeModel(model: Model<Api>): boolean {
+  if (model.provider === "opencode" || model.provider === "opencode-go") return true;
+
+  try {
+    return new URL(model.baseUrl).hostname === "opencode.ai";
+  } catch {
+    return false;
+  }
+}
+
+function hasHeader(headers: ProviderHeaders, name: string): boolean {
+  const lowerName = name.toLowerCase();
+  return Object.keys(headers).some((headerName) => headerName.toLowerCase() === lowerName);
+}
+
+function addOpenCodeDefaultHeaders(
+  model: Model<Api>,
+  affinityId: string,
+  headers: ProviderHeaders,
+): ProviderHeaders {
+  if (!isOpenCodeModel(model)) return headers;
+
+  const result = { ...headers };
+  if (!hasHeader(result, "x-opencode-session")) {
+    result["x-opencode-session"] = affinityId;
+  }
+  if (!hasHeader(result, "x-opencode-client")) {
+    result["x-opencode-client"] = "pi";
+  }
+  return result;
+}
+
+/**
+ * Complete a direct request through PI's model registry.
+ *
+ * PI resolves authentication, provider headers, environment, and the
+ * effective endpoint. This helper adds one stable opaque session identity for
+ * the feature prompt stream and applies the OpenCode compatibility defaults.
+ * It does not retry, validate output, or present errors.
+ *
+ * When `maxTokens` is omitted, the underlying registry receives no explicit
+ * output cap. A caller that needs the selected model's declared cap can pass
+ * `maxTokens: model.maxTokens` without importing PI internals.
+ */
+export async function completeModelRequest<TApi extends Api>(
+  ctx: ExtensionContext,
+  model: Model<TApi>,
+  context: Context,
+  options: CompleteModelRequestOptions<TApi>,
+): Promise<AssistantMessage> {
+  const { affinityScope, transformHeaders: callerTransformHeaders, ...requestOptions } = options;
+  const safeRequestOptions = { ...requestOptions };
+  delete safeRequestOptions.apiKey;
+  delete safeRequestOptions.env;
+  delete safeRequestOptions.sessionId;
+
+  const affinityId = createModelRequestAffinityId(
+    ctx.sessionManager.getSessionId(),
+    affinityScope,
+    model,
+  );
+  const transformHeaders = async (headers: ProviderHeaders): Promise<ProviderHeaders> => {
+    const transformed = callerTransformHeaders ? await callerTransformHeaders(headers) : headers;
+    return addOpenCodeDefaultHeaders(model, affinityId, transformed);
+  };
+
+  // Restore PI's conditional provider-option type after removing owned fields.
+  return ctx.modelRegistry.complete(model, context, {
+    ...safeRequestOptions,
+    signal: safeRequestOptions.signal ?? ctx.signal,
+    sessionId: affinityId,
+    transformHeaders,
+  } as unknown as ModelsApiStreamOptions<TApi>);
+}
 
 /**
  * Options for {@link withRetry}.
@@ -122,6 +241,8 @@ export function extractJsonFromResponse<T extends TSchema>(
 export interface CallWithJsonResponseOptions {
   /** The prompt to send to the LLM. */
   prompt: string;
+  /** Stable feature scope for request affinity. Do not include prompt or retry data. */
+  affinityScope: string;
   /** Optional data context appended to the prompt. */
   dataContext?: string;
   /** Maximum tokens for the response. Default: 4096 */
@@ -135,8 +256,9 @@ export interface CallWithJsonResponseOptions {
 /**
  * Call the LLM with a prompt and validate the JSON response against a TypeBox schema.
  *
- * Handles model resolution, auth, retry via `withRetry`, text extraction,
- * JSON regex matching, and TypeBox validation.
+ * Handles model resolution, retry via `withRetry`, text extraction, JSON
+ * matching, and TypeBox validation. The request itself stays under PI
+ * registry authority through {@link completeModelRequest}.
  *
  * Returns `null` when:
  * - No model is available
@@ -145,7 +267,7 @@ export interface CallWithJsonResponseOptions {
  * - JSON doesn't match the schema
  * - The request is aborted
  *
- * @param ctx - The extension context for model resolution and auth.
+ * @param ctx - The extension context for model selection and PI registry access.
  * @param options - Call options including prompt, schema, and retry config.
  * @param schema - TypeBox schema to validate the JSON response against.
  * @returns The parsed and validated result, or `null`.
@@ -155,14 +277,18 @@ export async function callWithJsonResponse<T extends TSchema>(
   options: CallWithJsonResponseOptions,
   schema: T,
 ): Promise<{ parsed: import("typebox").Static<T> } | null> {
-  const { prompt, dataContext, maxTokens = 4096, systemPrompt = "", retries = 2 } = options;
+  const {
+    prompt,
+    affinityScope,
+    dataContext,
+    maxTokens = 4096,
+    systemPrompt = "",
+    retries = 2,
+  } = options;
 
   const model = ctx.model ?? ctx.modelRegistry.getAvailable()[0] ?? null;
   if (!model) return null;
 
-  const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-  if (!auth.ok || !auth.apiKey) return null;
-
   const fullPrompt = dataContext
     ? `${prompt}
 
@@ -171,8 +297,9 @@ ${dataContext}`
     : prompt;
 
   const response = await withRetry(
-    async () => {
-      return complete(
+    async () =>
+      completeModelRequest(
+        ctx,
         model,
         {
           systemPrompt,
@@ -185,13 +312,11 @@ ${dataContext}`
           ],
         },
         {
-          apiKey: auth.apiKey,
-          headers: auth.headers,
+          affinityScope,
           signal: ctx.signal,
           maxTokens,
         },
-      );
-    },
+      ),
     { retries, baseDelayMs: 1000, signal: ctx.signal },
   );
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-antigravity",
-  "version": "6.4.0",
+  "version": "7.0.1",
   "description": "Bounded Antigravity tasks with isolated workspace access and evidence",
   "license": "MIT",
   "repository": {
@@ -36,7 +36,7 @@
     "docs/adr/*.md"
   ],
   "dependencies": {
-    "@mrclrchtr/supi-core": "workspace:*"
+    "@mrclrchtr/supi-core": "7.0.1"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-core"
@@ -61,11 +61,6 @@
       "optional": true
     }
   },
-  "devDependencies": {
-    "@mrclrchtr/supi-test-utils": "workspace:*",
-    "@types/node": "25.9.5",
-    "vitest": "4.1.11"
-  },
   "pi": {
     "extensions": [
       "./src/extension.ts"

package/src/catalogue.ts

@@ -8,7 +8,8 @@ export function buildModelCatalogueEnum(catalogue: readonly CuratedModel[]): TSc
     throw new Error("Cannot build an Antigravity model enum from an empty catalogue.");
   }
   return StringEnum([...catalogue] as [string, ...string[]], {
-    description: "Curated Antigravity model available to the current account.",
+    description:
+      "Curated Antigravity model available to the current account; new runs have no default.",
   });
 }
 

package/src/extension.ts

@@ -1,15 +1,17 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerAntigravityFooterContribution } from "./footer.ts";
 import { AntigravityRuntime } from "./runtime.ts";
 import { registerAntigravitySettings } from "./settings.ts";
 
 /** Register the opt-in Antigravity Run extension. */
 export default function antigravityExtension(pi: ExtensionAPI): void {
   const runtime = new AntigravityRuntime({ pi });
+  const footer = registerAntigravityFooterContribution(runtime);
   registerAntigravitySettings(pi, runtime);
 
-  pi.on("session_start", async (_event, ctx) => {
+  pi.on("session_start", (_event, ctx) => {
     runtime.rebuildHandles(ctx.sessionManager.getBranch());
-    await runtime.refresh(ctx.cwd, ctx);
+    void runtime.startRefresh(ctx.cwd, ctx);
   });
 
   pi.on("session_tree", (_event, ctx) => {
@@ -18,5 +20,6 @@ export default function antigravityExtension(pi: ExtensionAPI): void {
 
   pi.on("session_shutdown", async () => {
     await runtime.shutdown();
+    footer.dispose();
   });
 }

package/src/footer-constants.ts

@@ -0,0 +1,5 @@
+/** Footer status key shared by the stats-line contribution and Pi fallback. */
+export const ANTIGRAVITY_FOOTER_KEY = "supi-antigravity";
+
+/** Terminal-safe four-point star used for the ready indicator. */
+export const ANTIGRAVITY_READY_ICON = "✦";

package/src/footer.ts

@@ -0,0 +1,27 @@
+import { footerContributions } from "@mrclrchtr/supi-core/footer-registry";
+import { ANTIGRAVITY_FOOTER_KEY } from "./footer-constants.ts";
+import type { AntigravityRuntime } from "./runtime.ts";
+
+/** Register the Antigravity checking spinner and ready icon on the footer stats line. */
+export function registerAntigravityFooterContribution(runtime: AntigravityRuntime): {
+  dispose: () => void;
+} {
+  footerContributions.register({
+    key: ANTIGRAVITY_FOOTER_KEY,
+    placement: "stats-end",
+    priority: 110,
+    render: () => {
+      const icon = runtime.footerIcon;
+      return icon ? `| ${icon}` : "";
+    },
+  });
+
+  return {
+    dispose: unregisterAntigravityFooterContribution,
+  };
+}
+
+/** Remove the Antigravity ready icon from the footer. */
+export function unregisterAntigravityFooterContribution(): void {
+  footerContributions.unregister(ANTIGRAVITY_FOOTER_KEY);
+}

package/src/runtime.ts

@@ -1,14 +1,21 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { FOOTER_INVALIDATE_EVENT } from "@mrclrchtr/supi-core/footer-registry";
+import { BRAILLE_SPINNER_FRAMES, SPINNER_INTERVAL_MS } from "@mrclrchtr/supi-core/spinner-frames";
 import { type AntigravityAvailability, discoverAntigravityAvailability } from "./availability.ts";
 import { loadAntigravityConfig } from "./config.ts";
 import { ConversationHandleStore } from "./conversation/handles.ts";
+import { ANTIGRAVITY_FOOTER_KEY, ANTIGRAVITY_READY_ICON } from "./footer-constants.ts";
 import { getIsolatedAntigravityPaths, type IsolatedAntigravityPaths } from "./isolated-home.ts";
 import { registerAntigravityRunTool } from "./tool/antigravity_run/register.ts";
 import { ANTIGRAVITY_RUN_TOOL_NAME } from "./tool/antigravity_run/spec.ts";
 import type { CuratedModel } from "./types.ts";
 
-/** Context needed to show an availability warning. */
-export type AntigravityRefreshContext = { ui: Pick<ExtensionContext["ui"], "notify"> } | undefined;
+type FooterState = "idle" | "checking" | "ready";
+
+/** Context needed to report availability and update the footer. */
+export type AntigravityRefreshContext = {
+  ui: Pick<ExtensionContext["ui"], "notify" | "setStatus">;
+};
 
 /** Session runtime for immutable availability and Conversation Handle state. */
 export class AntigravityRuntime {
@@ -20,6 +27,10 @@ export class AntigravityRuntime {
   #availability: AntigravityAvailability | undefined;
   #refreshGeneration = 0;
   #refreshAbort: AbortController | undefined;
+  #statusUi: Pick<ExtensionContext["ui"], "setStatus"> | undefined;
+  #footerState: FooterState = "idle";
+  #spinnerTimer: ReturnType<typeof setInterval> | undefined;
+  #spinnerFrame = 0;
   #toolRegistered = false;
 
   constructor(options: {
@@ -39,22 +50,52 @@ export class AntigravityRuntime {
     return this.#availability;
   }
 
+  /** Whether the discovered Antigravity tool is ready for use. */
+  get isReady(): boolean {
+    return this.#footerState === "ready";
+  }
+
+  /** Return the animated checking icon or the settled ready icon for the footer. */
+  get footerIcon(): string | undefined {
+    if (this.#footerState === "checking") {
+      return BRAILLE_SPINNER_FRAMES[this.#spinnerFrame % BRAILLE_SPINNER_FRAMES.length];
+    }
+    return this.#footerState === "ready" ? ANTIGRAVITY_READY_ICON : undefined;
+  }
+
   /** Rebuild handles from the current PI branch. */
   rebuildHandles(branch: readonly unknown[]): void {
     this.handles.rebuild(branch);
   }
 
+  /** Start availability discovery without making Pi session startup wait. */
+  startRefresh(cwd: string, context?: AntigravityRefreshContext): Promise<void> {
+    return this.refresh(cwd, context).catch((error) => {
+      try {
+        // biome-ignore lint/suspicious/noConsole: unexpected failures must stay visible.
+        console.warn(`[supi-antigravity] Availability check failed: ${formatRefreshError(error)}`);
+        context?.ui.notify("Antigravity availability check failed. Reload PI to retry.", "warning");
+      } catch {
+        // PI may be shutting down while the refresh completes.
+      }
+    });
+  }
+
   /** Discover or reuse availability and synchronize the active tool. */
   async refresh(cwd: string, context?: AntigravityRefreshContext): Promise<void> {
     const generation = ++this.#refreshGeneration;
     this.#refreshAbort?.abort();
     const abortController = new AbortController();
     this.#refreshAbort = abortController;
+    if (context) this.#statusUi = context.ui;
+    this.#stopSpinner();
+    this.#setFooterState("idle");
     const config = loadAntigravityConfig(cwd, this.#homeDir);
     if (!config.agentToolEnabled) {
       this.#deactivateTool();
       return;
     }
+    this.#startSpinner();
 
     let availability = this.#availability;
     if (!availability) {
@@ -75,11 +116,21 @@ export class AntigravityRuntime {
     if (generation !== this.#refreshGeneration || abortController.signal.aborted) return;
     this.#availability = availability;
     if (availability.status === "available") {
-      this.#activateTool(availability.catalogue, availability.cliVersion);
+      try {
+        this.#activateTool(availability.catalogue, availability.cliVersion);
+      } catch (error) {
+        this.#stopSpinner();
+        this.#setFooterState("idle");
+        throw error;
+      }
+      this.#stopSpinner();
+      this.#setFooterState("ready");
       return;
     }
+    this.#stopSpinner();
+    this.#setFooterState("idle");
     this.#deactivateTool();
-    context?.ui.notify(availability.warning, "warning");
+    notifyRefreshWarning(context, availability.warning);
   }
 
   /** Stop in-flight discovery and clear session-local state. */
@@ -87,7 +138,10 @@ export class AntigravityRuntime {
     this.#refreshGeneration += 1;
     this.#refreshAbort?.abort();
     this.#refreshAbort = undefined;
+    this.#stopSpinner();
+    this.#setFooterState("idle");
     this.#deactivateTool();
+    this.#statusUi = undefined;
     this.handles.clear();
     await Promise.resolve();
   }
@@ -115,4 +169,71 @@ export class AntigravityRuntime {
       this.#pi.setActiveTools(activeTools.filter((name) => name !== ANTIGRAVITY_RUN_TOOL_NAME));
     }
   }
+
+  #startSpinner(): void {
+    this.#stopSpinner();
+    this.#spinnerFrame = 0;
+    this.#setFooterState("checking");
+    this.#spinnerTimer = setInterval(() => {
+      if (this.#footerState !== "checking") return;
+      this.#spinnerFrame = (this.#spinnerFrame + 1) % BRAILLE_SPINNER_FRAMES.length;
+      this.#publishFooter();
+      this.#invalidateFooter();
+    }, SPINNER_INTERVAL_MS);
+    this.#spinnerTimer.unref?.();
+  }
+
+  #stopSpinner(): void {
+    if (this.#spinnerTimer === undefined) return;
+    clearInterval(this.#spinnerTimer);
+    this.#spinnerTimer = undefined;
+  }
+
+  #setFooterState(state: FooterState): void {
+    const changed = this.#footerState !== state;
+    this.#footerState = state;
+    this.#publishFooter();
+    if (!changed) return;
+    this.#invalidateFooter();
+  }
+
+  #publishFooter(): void {
+    try {
+      this.#statusUi?.setStatus(ANTIGRAVITY_FOOTER_KEY, this.footerIcon);
+    } catch {
+      // PI may be shutting down while the footer status changes.
+    }
+  }
+
+  #invalidateFooter(): void {
+    try {
+      this.#pi.events.emit(FOOTER_INVALIDATE_EVENT, {});
+    } catch {
+      // Footer refresh is optional and must not change runtime state.
+    }
+  }
+}
+
+function formatRefreshError(error: unknown): string {
+  const message =
+    error instanceof Error
+      ? error.message
+      : typeof error === "object" &&
+          error !== null &&
+          "message" in error &&
+          typeof error.message === "string"
+        ? error.message
+        : String(error);
+  return message.replace(/\s+/g, " ").trim().slice(0, 200) || "unknown error";
+}
+
+function notifyRefreshWarning(
+  context: AntigravityRefreshContext | undefined,
+  message: string,
+): void {
+  try {
+    context?.ui.notify(message, "warning");
+  } catch {
+    // PI may be shutting down while the refresh reports its result.
+  }
 }

package/src/tool/antigravity_run/guidance.ts

@@ -1,3 +1,3 @@
 /** Selection guidance for the dynamically activated antigravity_run tool. */
 export const toolDescription =
-  "Consult an external model for focused web research, workspace analysis, or an independent second opinion.";
+  "Consult an external model for focused web research, design advice, workspace analysis, or an independent second opinion. Use direct tools for repository facts that do not need external analysis. Expose the current workspace only when the consultation needs repository evidence.";

package/src/tool/antigravity_run/input.ts

@@ -34,35 +34,46 @@ export function buildAntigravityRunSchema(catalogue: readonly CuratedModel[]): T
     maxLength: MAX_PROMPT_CHARS,
     description: "The bounded request to send to Antigravity.",
   });
-  const newInput = Type.Object(
+  // Keep the root schema an object. Some providers reject a top-level anyOf
+  // because function parameters must have `type: "object"`.
+  return Type.Object(
     {
       prompt,
-      new: Type.Object(
-        {
-          workspace: Type.Boolean({
-            description:
-              "Expose the current PI workspace, or use the empty Consultation Workspace.",
-          }),
-          model: buildModelCatalogueEnum(catalogue),
-        },
-        { additionalProperties: false },
+      new: Type.Optional(
+        Type.Object(
+          {
+            workspace: Type.Boolean({
+              description:
+                "true exposes the current PI workspace; false uses the empty Consultation Workspace. Use true only when repository evidence is needed.",
+            }),
+            model: buildModelCatalogueEnum(catalogue),
+          },
+          { additionalProperties: false },
+        ),
+      ),
+      continue: Type.Optional(
+        Type.Object(
+          {
+            handle: Type.String({
+              minLength: 1,
+              maxLength: MAX_HANDLE_CHARS,
+              description: "Conversation Handle returned by antigravity_run.",
+            }),
+          },
+          {
+            additionalProperties: false,
+            description: "Continue a prior run and inherit its model and workspace access.",
+          },
+        ),
       ),
     },
-    { additionalProperties: false },
-  );
-  const continueInput = Type.Object(
     {
-      prompt,
-      continue: Type.Object(
-        {
-          handle: Type.String({ minLength: 1, maxLength: MAX_HANDLE_CHARS }),
-        },
-        { additionalProperties: false },
-      ),
+      // `prompt` is required, so these bounds require exactly one branch.
+      minProperties: 2,
+      maxProperties: 2,
+      additionalProperties: false,
     },
-    { additionalProperties: false },
   );
-  return Type.Union([newInput, continueInput]);
 }
 
 /** Validate exact-one input and the model against the same catalogue. */