formagent-sdk 0.3.0 → 0.4.0

package/README.md

@@ -228,6 +228,8 @@ for await (const event of session.receive()) {
 
 ## Session Management
 
+**Default Behavior:** Sessions use in-memory storage by default. Conversation history is lost when the process exits. Use `FileSessionStorage` for persistence across restarts.
+
 ### Persistent Sessions
 
 Enable session persistence with `FileSessionStorage`:

package/dist/cli/index.js

@@ -1735,7 +1735,8 @@ class SessionImpl {
       const toolResult = await tool.execute(toolInput, context);
       let content = typeof toolResult.content === "string" ? toolResult.content : JSON.stringify(toolResult.content);
       if (needsTruncation(content)) {
-        content = await truncateToolOutput(content);
+        const truncationConfig = this.config.tempDir ? { tempDir: this.config.tempDir } : undefined;
+        content = await truncateToolOutput(content, truncationConfig);
       }
       toolResponse = toolResult;
       result = {
@@ -2115,6 +2116,111 @@ class SessionManagerImpl {
   }
 }
 
+// src/utils/retry.ts
+var DEFAULT_RETRY_OPTIONS = {
+  maxAttempts: 3,
+  initialDelay: 1000,
+  maxDelay: 30000,
+  backoffMultiplier: 2,
+  jitter: true,
+  onRetry: () => {},
+  signal: undefined
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function calculateDelay(attempt, initialDelay, maxDelay, backoffMultiplier, jitter) {
+  const delay = Math.min(initialDelay * Math.pow(backoffMultiplier, attempt), maxDelay);
+  if (jitter) {
+    return delay * (0.5 + Math.random() * 0.5);
+  }
+  return delay;
+}
+function isRetryableStatus(status) {
+  return status >= 500 || status === 429;
+}
+function isRetryableError(error) {
+  if (error instanceof TypeError) {
+    return error.message.includes("fetch") || error.message.includes("network") || error.message.includes("ECONNREFUSED") || error.message.includes("ETIMEDOUT") || error.message.includes("ECONNRESET");
+  }
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("rate_limit") || message.includes("rate limit")) {
+      return true;
+    }
+    if (message.includes("usage_limit") || message.includes("usage limit")) {
+      return true;
+    }
+    if (message.includes("timeout") || message.includes("timed out")) {
+      return true;
+    }
+    if (message.includes("5") || message.includes("502") || message.includes("503") || message.includes("504")) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractStatusCode(error) {
+  const match = error.message.match(/(\d{3})/);
+  return match ? parseInt(match[1], 10) : null;
+}
+async function withRetry(fn, options = {}) {
+  const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };
+  let lastError = null;
+  for (let attempt = 0;attempt < opts.maxAttempts; attempt++) {
+    if (opts.signal?.aborted) {
+      throw new Error("Request aborted");
+    }
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt >= opts.maxAttempts - 1) {
+        throw lastError;
+      }
+      const statusCode = extractStatusCode(lastError);
+      const isRetryable = statusCode !== null ? isRetryableStatus(statusCode) : isRetryableError(lastError);
+      if (!isRetryable) {
+        throw lastError;
+      }
+      const delay = calculateDelay(attempt, opts.initialDelay, opts.maxDelay, opts.backoffMultiplier, opts.jitter);
+      opts.onRetry(attempt + 1, lastError);
+      await sleep(delay);
+    }
+  }
+  throw lastError || new Error("Max retries exceeded");
+}
+async function fetchWithRetry(url, init, retryOptions) {
+  return withRetry(async () => {
+    const response = await fetch(url, init);
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      let errorMessage = `HTTP ${response.status}`;
+      try {
+        const errorJson = JSON.parse(errorText);
+        if (errorJson.error?.type) {
+          errorMessage += `: ${errorJson.error.type}`;
+        }
+        if (errorJson.error?.message) {
+          errorMessage += ` - ${errorJson.error.message}`;
+        }
+      } catch {
+        if (errorText) {
+          errorMessage += ` ${errorText}`;
+        }
+      }
+      const error = new Error(errorMessage);
+      error.status = response.status;
+      error.responseText = errorText;
+      throw error;
+    }
+    return response;
+  }, {
+    signal: init.signal,
+    ...retryOptions
+  });
+}
+
 // src/llm/anthropic.ts
 class AnthropicProvider {
   id = "anthropic";
@@ -2127,6 +2233,7 @@ class AnthropicProvider {
     /^claude-instant/
   ];
   config;
+  defaultRetryOptions;
   constructor(config = {}) {
     const apiKey = config.apiKey ?? process.env.ANTHROPIC_API_KEY;
     if (!apiKey) {
@@ -2136,7 +2243,15 @@ class AnthropicProvider {
       apiKey,
       baseUrl: config.baseUrl ?? process.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com",
       apiVersion: config.apiVersion ?? "2023-06-01",
-      defaultMaxTokens: config.defaultMaxTokens ?? 4096
+      defaultMaxTokens: config.defaultMaxTokens ?? 4096,
+      retry: config.retry
+    };
+    this.defaultRetryOptions = {
+      maxAttempts: 3,
+      initialDelay: 1000,
+      maxDelay: 30000,
+      backoffMultiplier: 2,
+      jitter: true
     };
   }
   supportsModel(model) {
@@ -2144,31 +2259,25 @@ class AnthropicProvider {
   }
   async complete(request) {
     const anthropicRequest = this.buildRequest(request, false);
-    const response = await fetch(`${this.config.baseUrl}/v1/messages`, {
+    const retryOptions = this.config.retry ?? this.defaultRetryOptions;
+    const response = await fetchWithRetry(`${this.config.baseUrl}/v1/messages`, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify(anthropicRequest),
       signal: request.abortSignal
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Anthropic API error: ${response.status} ${error}`);
-    }
+    }, retryOptions);
     const data = await response.json();
     return this.convertResponse(data);
   }
   async stream(request, options) {
     const anthropicRequest = this.buildRequest(request, true);
-    const response = await fetch(`${this.config.baseUrl}/v1/messages`, {
+    const retryOptions = this.config.retry ?? this.defaultRetryOptions;
+    const response = await fetchWithRetry(`${this.config.baseUrl}/v1/messages`, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify(anthropicRequest),
       signal: request.abortSignal
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Anthropic API error: ${response.status} ${error}`);
-    }
+    }, retryOptions);
     return this.createStreamIterator(response.body, options);
   }
   buildRequest(request, stream) {
@@ -2389,6 +2498,7 @@ class OpenAIProvider {
     /^chatgpt/
   ];
   config;
+  defaultRetryOptions;
   constructor(config = {}) {
     const apiKey = config.apiKey ?? process.env.OPENAI_API_KEY;
     if (!apiKey) {
@@ -2398,96 +2508,88 @@ class OpenAIProvider {
       apiKey,
       baseUrl: this.normalizeBaseUrl(config.baseUrl ?? process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1"),
       organization: config.organization,
-      defaultMaxTokens: config.defaultMaxTokens ?? 4096
+      defaultMaxTokens: config.defaultMaxTokens ?? 4096,
+      retry: config.retry
+    };
+    this.defaultRetryOptions = {
+      maxAttempts: 3,
+      initialDelay: 1000,
+      maxDelay: 30000,
+      backoffMultiplier: 2,
+      jitter: true
     };
   }
   supportsModel(model) {
     return this.supportedModels.some((pattern) => pattern.test(model));
   }
   async complete(request) {
+    const retryOptions = this.config.retry ?? this.defaultRetryOptions;
     if (this.usesResponsesApi(request.config.model)) {
       const openaiRequest2 = this.buildResponsesRequest(request, false);
-      const response2 = await fetch(`${this.config.baseUrl}/responses`, {
+      const response2 = await fetchWithRetry(`${this.config.baseUrl}/responses`, {
         method: "POST",
         headers: this.getHeaders(),
         body: JSON.stringify(openaiRequest2),
         signal: request.abortSignal
-      });
-      if (!response2.ok) {
-        const error = await response2.text();
-        throw new Error(`OpenAI API error: ${response2.status} ${error}`);
-      }
+      }, retryOptions);
       const data2 = await response2.json();
       return this.convertResponsesResponse(data2);
     }
     const openaiRequest = this.buildRequest(request, false);
-    let response = await fetch(`${this.config.baseUrl}/chat/completions`, {
+    const response = await fetchWithRetry(`${this.config.baseUrl}/chat/completions`, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify(openaiRequest),
       signal: request.abortSignal
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      if (this.shouldFallbackToResponses(response.status, error)) {
+    }, retryOptions);
+    if (response.status === 404) {
+      const errorText = await response.clone().text();
+      if (this.shouldFallbackToResponses(404, errorText)) {
         const fallbackRequest = this.buildResponsesRequest(request, false);
-        response = await fetch(`${this.config.baseUrl}/responses`, {
+        const fallbackResponse = await fetchWithRetry(`${this.config.baseUrl}/responses`, {
           method: "POST",
           headers: this.getHeaders(),
           body: JSON.stringify(fallbackRequest),
           signal: request.abortSignal
-        });
-        if (!response.ok) {
-          const fallbackError = await response.text();
-          throw new Error(`OpenAI API error: ${response.status} ${fallbackError}`);
-        }
-        const data2 = await response.json();
+        }, retryOptions);
+        const data2 = await fallbackResponse.json();
         return this.convertResponsesResponse(data2);
       }
-      throw new Error(`OpenAI API error: ${response.status} ${error}`);
     }
     const data = await response.json();
     return this.convertResponse(data);
   }
   async stream(request, options) {
+    const retryOptions = this.config.retry ?? this.defaultRetryOptions;
     if (this.usesResponsesApi(request.config.model)) {
       const openaiRequest2 = this.buildResponsesRequest(request, true);
-      const response2 = await fetch(`${this.config.baseUrl}/responses`, {
+      const response2 = await fetchWithRetry(`${this.config.baseUrl}/responses`, {
         method: "POST",
         headers: this.getHeaders(),
         body: JSON.stringify(openaiRequest2),
         signal: request.abortSignal
-      });
-      if (!response2.ok) {
-        const error = await response2.text();
-        throw new Error(`OpenAI API error: ${response2.status} ${error}`);
-      }
+      }, retryOptions);
       return this.createResponsesStreamIterator(response2.body, options);
     }
     const openaiRequest = this.buildRequest(request, true);
-    let response = await fetch(`${this.config.baseUrl}/chat/completions`, {
+    const response = await fetchWithRetry(`${this.config.baseUrl}/chat/completions`, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify(openaiRequest),
       signal: request.abortSignal
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      if (this.shouldFallbackToResponses(response.status, error)) {
+    }, retryOptions);
+    if (response.status === 404) {
+      const errorText = await response.clone().text();
+      if (this.shouldFallbackToResponses(404, errorText)) {
         const fallbackRequest = this.buildResponsesRequest(request, true);
-        response = await fetch(`${this.config.baseUrl}/responses`, {
+        const fallbackResponse = await fetchWithRetry(`${this.config.baseUrl}/responses`, {
           method: "POST",
           headers: this.getHeaders(),
           body: JSON.stringify(fallbackRequest),
           signal: request.abortSignal
-        });
-        if (!response.ok) {
-          const fallbackError = await response.text();
-          throw new Error(`OpenAI API error: ${response.status} ${fallbackError}`);
-        }
-        return this.createResponsesStreamIterator(response.body, options);
+        }, retryOptions);
+        return this.createResponsesStreamIterator(fallbackResponse.body, options);
       }
-      throw new Error(`OpenAI API error: ${response.status} ${error}`);
     }
     return this.createStreamIterator(response.body, options);
   }
@@ -3202,6 +3304,7 @@ class GeminiProvider {
   name = "Gemini";
   supportedModels = [/^gemini-/, /^models\/gemini-/];
   config;
+  defaultRetryOptions;
   constructor(config = {}) {
     const apiKey = config.apiKey ?? process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
     if (!apiKey) {
@@ -3210,7 +3313,15 @@ class GeminiProvider {
     this.config = {
       apiKey,
       baseUrl: config.baseUrl ?? process.env.GEMINI_BASE_URL ?? "https://generativelanguage.googleapis.com/v1beta",
-      defaultMaxTokens: config.defaultMaxTokens ?? 4096
+      defaultMaxTokens: config.defaultMaxTokens ?? 4096,
+      retry: config.retry
+    };
+    this.defaultRetryOptions = {
+      maxAttempts: 3,
+      initialDelay: 1000,
+      maxDelay: 30000,
+      backoffMultiplier: 2,
+      jitter: true
     };
   }
   supportsModel(model) {
@@ -3219,16 +3330,13 @@ class GeminiProvider {
   async complete(request) {
     const geminiRequest = this.buildRequest(request);
     const url = this.buildUrl(this.getModelPath(request.config.model) + ":generateContent");
-    const response = await fetch(url, {
+    const retryOptions = this.config.retry ?? this.defaultRetryOptions;
+    const response = await fetchWithRetry(url, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify(geminiRequest),
       signal: request.abortSignal
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Gemini API error: ${response.status} ${error}`);
-    }
+    }, retryOptions);
     const data = await response.json();
     return this.convertResponse(data, request.config.model);
   }
@@ -3237,16 +3345,13 @@ class GeminiProvider {
     const url = this.buildUrl(this.getModelPath(request.config.model) + ":streamGenerateContent", {
       alt: "sse"
     });
-    const response = await fetch(url, {
+    const retryOptions = this.config.retry ?? this.defaultRetryOptions;
+    const response = await fetchWithRetry(url, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify(geminiRequest),
       signal: request.abortSignal
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Gemini API error: ${response.status} ${error}`);
-    }
+    }, retryOptions);
     const contentType = response.headers.get("content-type") ?? "";
     if (!contentType.includes("text/event-stream")) {
       const data = await response.json();
@@ -4262,6 +4367,7 @@ function checkDirAccess(dirPath, options) {
 
 // src/tools/builtin/bash.ts
 var DEFAULT_TIMEOUT = 120000;
+var DEFAULT_IDLE_TIMEOUT = 30000;
 var MAX_OUTPUT_LENGTH = 1e5;
 var DEFAULT_BLOCKED_PATTERNS = [
   "\\bsudo\\b",
@@ -4328,21 +4434,39 @@ function createBashTool(options = {}) {
         }
       }
       const actualTimeout = Math.min(timeout, 600000);
+      const idleTimeout = options.idleTimeout ?? DEFAULT_IDLE_TIMEOUT;
       return new Promise((resolve2) => {
         let stdout = "";
         let stderr = "";
         let killed = false;
+        let killedReason = null;
+        let lastOutputTime = Date.now();
         const proc = spawn("bash", ["-c", command], {
           cwd: cwdAccess.resolved,
           env: process.env,
-          shell: false
+          shell: false,
+          stdio: ["ignore", "pipe", "pipe"]
         });
         const timer = setTimeout(() => {
           killed = true;
+          killedReason = "timeout";
           proc.kill("SIGTERM");
           setTimeout(() => proc.kill("SIGKILL"), 1000);
         }, actualTimeout);
+        const idleChecker = setInterval(() => {
+          const idleTime = Date.now() - lastOutputTime;
+          if (idleTime >= idleTimeout && !killed) {
+            killed = true;
+            killedReason = "idle";
+            proc.kill("SIGTERM");
+            setTimeout(() => proc.kill("SIGKILL"), 1000);
+          }
+        }, 1000);
+        const updateLastOutputTime = () => {
+          lastOutputTime = Date.now();
+        };
         proc.stdout?.on("data", (data) => {
+          updateLastOutputTime();
           stdout += data.toString();
           if (stdout.length > MAX_OUTPUT_LENGTH) {
             stdout = stdout.slice(0, MAX_OUTPUT_LENGTH) + `
@@ -4351,6 +4475,7 @@ function createBashTool(options = {}) {
           }
         });
         proc.stderr?.on("data", (data) => {
+          updateLastOutputTime();
           stderr += data.toString();
           if (stderr.length > MAX_OUTPUT_LENGTH) {
             stderr = stderr.slice(0, MAX_OUTPUT_LENGTH) + `
@@ -4359,17 +4484,31 @@ function createBashTool(options = {}) {
         });
         proc.on("close", (code) => {
           clearTimeout(timer);
+          clearInterval(idleChecker);
           if (killed) {
-            resolve2({
-              content: `Command timed out after ${actualTimeout}ms
+            if (killedReason === "idle") {
+              resolve2({
+                content: `Command terminated: no output for ${idleTimeout / 1000} seconds (likely waiting for input)
 
 Partial output:
 ${stdout}
 
 Stderr:
 ${stderr}`,
-              isError: true
-            });
+                isError: true
+              });
+            } else {
+              resolve2({
+                content: `Command timed out after ${actualTimeout}ms
+
+Partial output:
+${stdout}
+
+Stderr:
+${stderr}`,
+                isError: true
+              });
+            }
             return;
           }
           const output = stdout + (stderr ? `
@@ -4390,6 +4529,7 @@ ${output}`,
         });
         proc.on("error", (error) => {
           clearTimeout(timer);
+          clearInterval(idleChecker);
           resolve2({
             content: `Failed to execute command: ${error.message}`,
             isError: true
@@ -6029,7 +6169,7 @@ ${responseText}`;
           metadata: {
             status: response.status,
             statusText: response.statusText,
-            headers: Object.fromEntries(response.headers.entries()),
+            headers: Object.fromEntries(response.headers),
             body: responseBody
           }
         };
@@ -6200,14 +6340,17 @@ ${c.bold("Interactive Commands:")}
   ${c.cyan("/exit")}     Exit the CLI
 
 ${c.bold("Environment:")}
-  ${c.cyan("ANTHROPIC_API_KEY")}   Anthropic API key (for Claude models)
-  ${c.cyan("ANTHROPIC_MODEL")}     Optional. Claude model (default: claude-sonnet-4-20250514)
-  ${c.cyan("GEMINI_API_KEY")}      Gemini API key (for Gemini models)
-  ${c.cyan("GEMINI_MODEL")}        Optional. Gemini model (default: gemini-1.5-pro)
-  ${c.cyan("GEMINI_BASE_URL")}     Optional. Custom Gemini API base URL
-  ${c.cyan("OPENAI_API_KEY")}      OpenAI API key (for GPT models)
-  ${c.cyan("OPENAI_MODEL")}        Optional. OpenAI model (default: gpt-5.2)
-  ${c.cyan("OPENAI_BASE_URL")}     Optional. Custom OpenAI-compatible API URL
+  ${c.cyan("ANTHROPIC_API_KEY")}     Anthropic API key (for Claude models)
+  ${c.cyan("ANTHROPIC_MODEL")}       Optional. Claude model (default: claude-sonnet-4-20250514)
+  ${c.cyan("GEMINI_API_KEY")}        Gemini API key (for Gemini models)
+  ${c.cyan("GEMINI_MODEL")}          Optional. Gemini model (default: gemini-1.5-pro)
+  ${c.cyan("GEMINI_BASE_URL")}       Optional. Custom Gemini API base URL
+  ${c.cyan("OPENAI_API_KEY")}        OpenAI API key (for GPT models)
+  ${c.cyan("OPENAI_MODEL")}          Optional. OpenAI model (default: gpt-5.2)
+  ${c.cyan("OPENAI_BASE_URL")}       Optional. Custom OpenAI-compatible API URL
+  ${c.cyan("ANTIGRAVITY_API_KEY")}   Antigravity API key (default: sk-antigravity)
+  ${c.cyan("ANTIGRAVITY_MODEL")}     Optional. Antigravity model (default: gemini-3-flash)
+  ${c.cyan("ANTIGRAVITY_BASE_URL")}  Optional. Antigravity gateway URL (default: http://127.0.0.1:8045)
 
 ${c.bold("Examples:")}
   ${c.dim("# Start interactive mode")}
@@ -6343,6 +6486,7 @@ function printModelsHelp() {
   console.log(`  ${c.cyan("/models")} openai gpt-5-mini`);
   console.log(`  ${c.cyan("/models")} anthropic claude-sonnet-4-20250514`);
   console.log(`  ${c.cyan("/models")} gemini gemini-1.5-pro`);
+  console.log(`  ${c.cyan("/models")} antigravity gemini-3-flash`);
   console.log(`  ${c.cyan("/models")} gpt-5.2`);
   console.log(`  ${c.cyan("/models")} reset`);
   console.log();
@@ -6383,7 +6527,7 @@ async function handleModelsCommand(args) {
   const provider = parseProvider(args[0]);
   if (!provider) {
     console.log(c.yellow(`
-  Unknown provider: ${args[0]}. Use "openai", "anthropic", or "gemini".
+  Unknown provider: ${args[0]}. Use "openai", "anthropic", "gemini", or "antigravity".
 `));
     return;
   }
@@ -6527,6 +6671,34 @@ async function listGeminiModels() {
   }
   console.log();
 }
+async function listAntigravityModels() {
+  const config = getAntigravityConfig();
+  const baseUrl = `${config.baseUrl}/v1`;
+  console.log(c.bold("Antigravity Models:"));
+  console.log(c.dim("  API Type: openai-compatible (Antigravity Gateway)"));
+  console.log(c.dim(`  Base URL: ${baseUrl}`));
+  console.log(c.dim(`  Default Model: ${config.model}`));
+  const res = await fetch(`${baseUrl}/models`, {
+    headers: {
+      Authorization: `Bearer ${config.apiKey}`,
+      "x-api-key": config.apiKey
+    }
+  });
+  if (!res.ok) {
+    console.log(c.red(`  ✗ Failed to fetch models (${res.status})`));
+    console.log(c.dim(`  URL: ${baseUrl}/models`));
+    console.log(c.dim("  Make sure Antigravity Manager is running"));
+    console.log();
+    return;
+  }
+  const payload = await res.json();
+  const items = payload.data ?? [];
+  for (const item of items) {
+    const owner = item.owned_by ? ` (${item.owned_by})` : "";
+    console.log(`  ${c.green("●")} ${item.id}${owner}`);
+  }
+  console.log();
+}
 async function listModelsSummary() {
   const provider = getActiveProviderId();
   const apiType = provider ?? "auto";
@@ -6547,6 +6719,12 @@ async function listModelsSummary() {
     console.log(c.red(`  ✗ Gemini: ${error instanceof Error ? error.message : String(error)}`));
     console.log();
   }
+  try {
+    await listAntigravityModels();
+  } catch (error) {
+    console.log(c.red(`  ✗ Antigravity: ${error instanceof Error ? error.message : String(error)}`));
+    console.log();
+  }
   await listAnthropicModels();
 }
 function printDebug() {
@@ -6566,16 +6744,20 @@ function printDebug() {
   console.log(`  ${c.cyan("ANTHROPIC_MODEL:")} ${process.env.ANTHROPIC_MODEL || c.dim("(not set)")}`);
   console.log(`  ${c.cyan("GEMINI_MODEL:")}    ${process.env.GEMINI_MODEL || c.dim("(not set)")}`);
   console.log(`  ${c.cyan("GEMINI_BASE_URL:")} ${process.env.GEMINI_BASE_URL || c.dim("(not set)")}`);
-  console.log(`  ${c.cyan("OPENAI_MODEL:")}    ${process.env.OPENAI_MODEL || c.dim("(not set)")}`);
-  console.log(`  ${c.cyan("OPENAI_BASE_URL:")} ${process.env.OPENAI_BASE_URL || c.dim("(not set)")}`);
+  console.log(`  ${c.cyan("OPENAI_MODEL:")}       ${process.env.OPENAI_MODEL || c.dim("(not set)")}`);
+  console.log(`  ${c.cyan("OPENAI_BASE_URL:")}    ${process.env.OPENAI_BASE_URL || c.dim("(not set)")}`);
+  console.log(`  ${c.cyan("ANTIGRAVITY_MODEL:")}  ${process.env.ANTIGRAVITY_MODEL || c.dim("(not set)")}`);
+  console.log(`  ${c.cyan("ANTIGRAVITY_BASE_URL:")} ${process.env.ANTIGRAVITY_BASE_URL || c.dim("(not set)")}`);
   console.log();
   console.log(c.bold("API Keys:"));
   const anthropicKey = process.env.ANTHROPIC_API_KEY;
   const geminiKey = process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
   const openaiKey = process.env.OPENAI_API_KEY;
-  console.log(`  ${c.cyan("ANTHROPIC_API_KEY:")} ${anthropicKey ? c.green("✓ set") + c.dim(` (${anthropicKey.slice(0, 8)}...${anthropicKey.slice(-4)})`) : c.red("✗ not set")}`);
-  console.log(`  ${c.cyan("GEMINI_API_KEY:")}    ${geminiKey ? c.green("✓ set") + c.dim(` (${geminiKey.slice(0, 8)}...${geminiKey.slice(-4)})`) : c.red("✗ not set")}`);
-  console.log(`  ${c.cyan("OPENAI_API_KEY:")}    ${openaiKey ? c.green("✓ set") + c.dim(` (${openaiKey.slice(0, 8)}...${openaiKey.slice(-4)})`) : c.red("✗ not set")}`);
+  const antigravityKey = process.env.ANTIGRAVITY_API_KEY;
+  console.log(`  ${c.cyan("ANTHROPIC_API_KEY:")}   ${anthropicKey ? c.green("✓ set") + c.dim(` (${anthropicKey.slice(0, 8)}...${anthropicKey.slice(-4)})`) : c.red("✗ not set")}`);
+  console.log(`  ${c.cyan("GEMINI_API_KEY:")}      ${geminiKey ? c.green("✓ set") + c.dim(` (${geminiKey.slice(0, 8)}...${geminiKey.slice(-4)})`) : c.red("✗ not set")}`);
+  console.log(`  ${c.cyan("OPENAI_API_KEY:")}      ${openaiKey ? c.green("✓ set") + c.dim(` (${openaiKey.slice(0, 8)}...${openaiKey.slice(-4)})`) : c.red("✗ not set")}`);
+  console.log(`  ${c.cyan("ANTIGRAVITY_API_KEY:")} ${antigravityKey ? c.green("✓ set") + c.dim(` (${antigravityKey.slice(0, 8)}...${antigravityKey.slice(-4)})`) : c.dim("(default: sk-antigravity)")}`);
   console.log();
   console.log(c.bold("Environment:"));
   console.log(`  ${c.cyan("Working dir:")}  ${cwd}`);
@@ -6639,6 +6821,9 @@ function formatToolInput(name, input) {
   }
 }
 function getDefaultProviderFromEnv() {
+  if (process.env.ANTIGRAVITY_API_KEY || process.env.ANTIGRAVITY_BASE_URL) {
+    return "antigravity";
+  }
   if (process.env.ANTHROPIC_API_KEY) {
     return "anthropic";
   }
@@ -6670,6 +6855,9 @@ function getDefaultModelForProvider(providerId) {
   if (providerId === "gemini") {
     return process.env.GEMINI_MODEL || "gemini-1.5-pro";
   }
+  if (providerId === "antigravity") {
+    return process.env.ANTIGRAVITY_MODEL || "gemini-3-flash";
+  }
   return process.env.OPENAI_MODEL || "gpt-5.2";
 }
 function getActiveProviderId() {
@@ -6702,8 +6890,17 @@ function parseProvider(arg) {
   if (normalized === "gemini" || normalized === "google") {
     return "gemini";
   }
+  if (normalized === "antigravity" || normalized === "ag") {
+    return "antigravity";
+  }
   return null;
 }
+function getAntigravityConfig() {
+  const baseUrl = (process.env.ANTIGRAVITY_BASE_URL || "http://127.0.0.1:8045").replace(/\/+$/, "");
+  const apiKey = process.env.ANTIGRAVITY_API_KEY || "sk-antigravity";
+  const model = process.env.ANTIGRAVITY_MODEL || "gemini-3-flash";
+  return { baseUrl, apiKey, model };
+}
 function createProvider(providerId) {
   if (providerId === "anthropic") {
     return new AnthropicProvider;
@@ -6714,6 +6911,13 @@ function createProvider(providerId) {
       baseUrl: process.env.GEMINI_BASE_URL
     });
   }
+  if (providerId === "antigravity") {
+    const config = getAntigravityConfig();
+    return new OpenAIProvider({
+      apiKey: config.apiKey,
+      baseUrl: `${config.baseUrl}/v1`
+    });
+  }
   return new OpenAIProvider({
     apiKey: process.env.OPENAI_API_KEY,
     baseUrl: process.env.OPENAI_BASE_URL