clay-server 3.4.0-beta.1 → 3.4.0-beta.3

package/lib/public/modules/shell-command.js

@@ -0,0 +1,148 @@
+import { store } from './store.js';
+import { getWs } from './ws-ref.js';
+import { iconHtml, refreshIcons } from './icons.js';
+import { showToast } from './utils.js';
+
+var defaultPlaceholder = "";
+
+function getInput() {
+  return document.getElementById("input");
+}
+
+function appendToMessages(element) {
+  var messages = document.getElementById("messages");
+  if (!messages) return;
+  messages.appendChild(element);
+  requestAnimationFrame(function () { messages.scrollTop = messages.scrollHeight; });
+}
+
+function setMode(active) {
+  var input = getInput();
+  var button = document.getElementById("shell-command-btn");
+  var row = document.getElementById("input-row");
+  store.set({ shellCommandMode: active });
+  if (button) {
+    button.classList.toggle("active", active);
+    button.setAttribute("aria-pressed", active ? "true" : "false");
+  }
+  if (row) row.classList.toggle("shell-command-mode", active);
+  if (input) {
+    if (!defaultPlaceholder) defaultPlaceholder = input.placeholder;
+    input.placeholder = active ? "Run a shell command in this project…" : defaultPlaceholder;
+    input.focus();
+  }
+}
+
+export function isShellCommandMode() {
+  return !!store.get("shellCommandMode");
+}
+
+export function toggleShellCommandMode() {
+  if (store.get("shellCommandRunning")) return;
+  var target = store.get("dmTargetUser");
+  if (store.get("dmMode") && target && !target.isMate) {
+    showToast("Shell commands are available in agent sessions, not user DMs.", "error");
+    return;
+  }
+  setMode(!isShellCommandMode());
+}
+
+function renderPendingCommand(requestId, command) {
+  var card = document.createElement("div");
+  card.className = "shell-command-card running";
+  card.dataset.requestId = requestId;
+  card.innerHTML =
+    '<div class="shell-command-header">' +
+      '<span class="shell-command-icon">' + iconHtml("square-terminal") + '</span>' +
+      '<code></code><span class="shell-command-status">Running…</span>' +
+    '</div>' +
+    '<pre class="shell-command-output">Waiting for output…</pre>';
+  card.querySelector("code").textContent = "$ " + command;
+  appendToMessages(card);
+  refreshIcons();
+}
+
+export function submitShellCommand(command) {
+  command = String(command || "").trim();
+  if (!command || store.get("shellCommandRunning")) return false;
+  var ws = getWs();
+  if (!ws || ws.readyState !== 1) {
+    showToast("Not connected — command not run.", "error");
+    return false;
+  }
+
+  var requestId = "shell_" + Date.now() + "_" + Math.random().toString(36).slice(2, 9);
+  store.set({ shellCommandRunning: true, pendingShellCommandId: requestId });
+  var input = getInput();
+  if (input) {
+    input.disabled = true;
+    input.placeholder = "Running command…";
+  }
+  renderPendingCommand(requestId, command);
+  ws.send(JSON.stringify({ type: "shell_command", requestId: requestId, command: command }));
+  return true;
+}
+
+export function handleShellCommandResult(msg) {
+  var cards = document.querySelectorAll(".shell-command-card[data-request-id]");
+  var card = null;
+  for (var i = 0; i < cards.length; i++) {
+    if (cards[i].dataset.requestId === (msg.requestId || "")) {
+      card = cards[i];
+      break;
+    }
+  }
+  if (card) {
+    var status = card.querySelector(".shell-command-status");
+    var output = card.querySelector(".shell-command-output");
+    card.classList.remove("running");
+    if (msg.error) {
+      card.classList.add("error");
+      if (status) status.textContent = "Failed";
+      if (output) output.textContent = msg.error;
+    } else {
+      card.classList.toggle("error", msg.exitCode !== 0);
+      if (status) status.textContent = msg.timedOut ? "Timed out" : "Exit " + (msg.exitCode == null ? "—" : msg.exitCode);
+      if (output) output.textContent = msg.output || "(no output)";
+    }
+  }
+
+  store.set({ shellCommandRunning: false, pendingShellCommandId: null });
+  var input = getInput();
+  if (input) input.disabled = false;
+  if (msg.error) {
+    setMode(true);
+  } else {
+    setMode(false);
+  }
+  var messages = document.getElementById("messages");
+  if (messages) requestAnimationFrame(function () { messages.scrollTop = messages.scrollHeight; });
+}
+
+export function initShellCommand() {
+  var button = document.getElementById("shell-command-btn");
+  var mobileButton = document.getElementById("input-more-shell");
+  if (button) button.addEventListener("click", toggleShellCommandMode);
+  if (mobileButton) {
+    mobileButton.addEventListener("click", function () {
+      var sheet = document.getElementById("input-more-sheet");
+      if (sheet) {
+        sheet.classList.remove("open");
+        setTimeout(function () { sheet.classList.add("hidden"); }, 250);
+      }
+      toggleShellCommandMode();
+    });
+  }
+  store.subscribe(function (state, previous) {
+    if (previous.connected && !state.connected && state.shellCommandRunning) {
+      resetShellCommand();
+    }
+  });
+}
+
+export function resetShellCommand() {
+  store.set({ shellCommandMode: false, shellCommandRunning: false, pendingShellCommandId: null });
+  var input = getInput();
+  if (input) input.disabled = false;
+  setMode(false);
+}

package/lib/public/modules/sidebar-mates.js

@@ -460,7 +460,7 @@ export function renderUserStrip(allUsers, onlineUserIds, myUserId, dmFavorites,
       var vendorLabels = {
         claude: "Claude Code",
         codex: "OpenAI Codex",
-        gemini: "Gemini CLI",
+        antigravity: "Antigravity CLI",
         opencode: "OpenCode",
         kiro: "Kiro CLI",
       };

package/lib/public/modules/tools.js

@@ -817,7 +817,7 @@ function resolvePermissionIdentity(mateId, vendor) {
   var vendorAvatars = {
     claude: "/claude-code-avatar.png",
     codex: "/codex-avatar.png",
-    gemini: "/gemini-avatar.svg",
+    antigravity: "/antigravity-avatar.png",
     opencode: "/opencode-avatar.svg",
     kiro: "/kiro-avatar.svg",
   };

package/lib/sdk-bridge.js

@@ -1528,6 +1528,10 @@ function createSDKBridge(opts) {
         ACP: {
           mcpServers: getAcpMcpServers(session),
         },
+        ANTIGRAVITY: {
+          dangerouslySkipPermissions: dangerouslySkipPermissions
+            || session.permissionMode === "bypassPermissions",
+        },
         KIRO: {
           engine: kiroConfig.engine,
           mode: kiroConfig.mode,
@@ -1790,16 +1794,20 @@ function createSDKBridge(opts) {
     } catch (e) {}
     if ((codexBin && fs.existsSync(codexBin)) || tryLookup(yoke.getVendorInfo("codex").binaryName)) result.push("codex");
 
-    var acpVendorKeys = ["gemini", "opencode"];
+    var subprocessVendorKeys = ["antigravity", "opencode"];
     var acpProfiles = require("./yoke/acp-agent-profiles");
-    for (var acpVendorIndex = 0; acpVendorIndex < acpVendorKeys.length; acpVendorIndex++) {
-      var acpVendor = acpVendorKeys[acpVendorIndex];
-      var acpInfo = yoke.getVendorInfo(acpVendor);
-      if (!linuxUser || acpInfo.osUserIsolation) {
-        var acpProfile = acpProfiles.getAcpAgentProfile(acpVendor);
-        if (acpProfiles.findAcpAgentPath(acpProfile)) result.push(acpVendor);
+    for (var subprocessVendorIndex = 0; subprocessVendorIndex < subprocessVendorKeys.length; subprocessVendorIndex++) {
+      var subprocessVendor = subprocessVendorKeys[subprocessVendorIndex];
+      var subprocessInfo = yoke.getVendorInfo(subprocessVendor);
+      if (!linuxUser || subprocessInfo.osUserIsolation) {
+        if (subprocessVendor === "antigravity") {
+          if (tryLookup(subprocessInfo.binaryName)) result.push(subprocessVendor);
+        } else {
+          var acpProfile = acpProfiles.getAcpAgentProfile(subprocessVendor);
+          if (acpProfiles.findAcpAgentPath(acpProfile)) result.push(subprocessVendor);
+        }
       } else {
-        console.log("[sdk-bridge] " + acpInfo.displayName + " hidden for OS-isolated user " + linuxUser + ": per-user spawning is not implemented");
+        console.log("[sdk-bridge] " + subprocessInfo.displayName + " hidden for OS-isolated user " + linuxUser + ": per-user spawning is not implemented");
       }
     }
 

package/lib/sdk-message-processor.js

@@ -792,7 +792,16 @@ function attachMessageProcessor(ctx) {
       // processQueryStream can finish the turn when the iterator closes.
       var adapterErrorText = parsed.text || parsed.message || parsed.error || "Agent runtime error";
       session._lastAdapterError = adapterErrorText;
-      sendAndRecord(session, { type: "error", text: adapterErrorText });
+      var isSessionWriterConflict = /thread-store conflict|already has an active writer/i.test(adapterErrorText);
+      if (isSessionWriterConflict) {
+        sendAndRecord(session, {
+          type: "session_writer_conflict",
+          vendor: session.vendor || "codex",
+          text: "This Codex session is already open in another Clay or Codex process. Stop the other server or close the other session, then try again.",
+        });
+      } else {
+        sendAndRecord(session, { type: "error", text: adapterErrorText });
+      }
 
     } else if (parsed.yokeType === "model_refusal") {
       // Model declined the request. "fallback" => the CLI retried on another

package/lib/ws-schema.js

@@ -145,6 +145,7 @@ var schema = {
   "kill_process":             { direction: "c2s", handler: "lib/project-sessions.js", description: "Kill a system process by PID" },
   "process_killed":           { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Process was successfully killed" },
   "process_conflict":         { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Conflict: another process is using the session" },
+  "session_writer_conflict":  { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Codex session is already open in another process" },
 
   // -----------------------------------------------------------------------
   // Context / usage
@@ -353,6 +354,8 @@ var schema = {
   "term_closed":              { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Terminal session was closed" },
   "term_list":                { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Full list of open terminals" },
   "term_error":               { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "Terminal error (e.g. access denied)" },
+  "shell_command":            { direction: "c2s", handler: "lib/project-shell-command.js", description: "Run a one-shot shell command for agent context" },
+  "shell_command_result":     { direction: "s2c", handler: "lib/public/modules/app-messages.js", description: "One-shot shell command output and exit status" },
 
   // -----------------------------------------------------------------------
   // Sticky notes

package/lib/yoke/acp-agent-profiles.js

@@ -97,20 +97,6 @@ function validateOpenCodeConfig(config) {
 }
 
 var ACP_AGENT_PROFILES = {
-  gemini: {
-    vendor: "gemini",
-    displayName: "Gemini CLI",
-    binaryName: "gemini",
-    overrideName: "GEMINI_CLI_PATH",
-    args: ["--acp", "--approval-mode=default"],
-    defaultModels: ["auto"],
-    defaultModel: "auto",
-    // Gemini advertises loadSession, but releases through 0.46.0 could load
-    // the transcript without restoring the model's conversation memory.
-    // Keep resume gated until Clay's live contract test proves it reliable.
-    sessionResume: false,
-    permissionModeGuaranteed: true,
-  },
   opencode: {
     vendor: "opencode",
     displayName: "OpenCode",

package/lib/yoke/adapters/antigravity.js

@@ -0,0 +1,417 @@
+var childProcess = require("child_process");
+var readline = require("readline");
+var skillDiscovery = require("../skill-discovery");
+
+function findBinary() {
+  if (process.env.ANTIGRAVITY_CLI_PATH) return process.env.ANTIGRAVITY_CLI_PATH;
+  try {
+    var command = process.platform === "win32" ? "where" : "which";
+    return childProcess.execFileSync(command, ["agy"], {
+      encoding: "utf8",
+      timeout: 3000,
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim().split(/\r?\n/)[0] || null;
+  } catch (e) {
+    return null;
+  }
+}
+
+function modelValue(model) {
+  if (typeof model === "string") return model;
+  return model && (model.id || model.slug || model.value || model.model);
+}
+
+function parseModels(stdout) {
+  try {
+    var parsed = JSON.parse(String(stdout || ""));
+    var list = Array.isArray(parsed) ? parsed : (parsed.models || parsed.data || []);
+    var models = [];
+    for (var i = 0; i < list.length; i++) {
+      var value = modelValue(list[i]);
+      if (value && models.indexOf(value) === -1) models.push(value);
+    }
+    return models;
+  } catch (e) {
+    var lines = String(stdout || "").split(/\r?\n/);
+    var fallback = [];
+    for (var j = 0; j < lines.length; j++) {
+      var match = lines[j].trim().match(/^([^\s]+)\s+/);
+      if (match && fallback.indexOf(match[1]) === -1) fallback.push(match[1]);
+    }
+    return fallback;
+  }
+}
+
+function fetchModels(binaryPath, cwd) {
+  return new Promise(function(resolve) {
+    childProcess.execFile(binaryPath, ["models", "--output-format", "json"], {
+      cwd: cwd || process.cwd(),
+      timeout: 20000,
+      maxBuffer: 4 * 1024 * 1024,
+    }, function(err, stdout) {
+      if (err || !stdout) { resolve([]); return; }
+      resolve(parseModels(stdout));
+    });
+  });
+}
+
+function isAuthError(value) {
+  return /authentication required|not authenticated|sign in|log ?in|credentials|unauthorized|forbidden|\b401\b/i.test(String(value || ""));
+}
+
+function toolName(name) {
+  var value = String(name || "").toLowerCase();
+  if (value === "run_command" || value === "shell" || value === "bash") return "Bash";
+  if (value.indexOf("read") !== -1) return "Read";
+  if (value.indexOf("write") !== -1 || value.indexOf("create") !== -1) return "Write";
+  if (value.indexOf("edit") !== -1 || value.indexOf("replace") !== -1 || value.indexOf("delete") !== -1) return "Edit";
+  if (value.indexOf("search_web") !== -1 || value.indexOf("web_search") !== -1) return "WebSearch";
+  if (value.indexOf("fetch") !== -1 || value.indexOf("url") !== -1) return "WebFetch";
+  if (value.indexOf("search") !== -1 || value.indexOf("grep") !== -1) return "Grep";
+  if (value.indexOf("glob") !== -1 || value.indexOf("find") !== -1) return "Glob";
+  if (value.indexOf("subagent") !== -1 || value.indexOf("task") !== -1) return "Task";
+  return name || "Tool";
+}
+
+function createAntigravityQueryHandle(binaryPath, queryOpts, onFinished) {
+  var processHandle = null;
+  var outputReader = null;
+  var events = [];
+  var eventWaiter = null;
+  var messages = [];
+  var started = false;
+  var activeTurn = false;
+  var ended = false;
+  var inputEnded = false;
+  var finished = false;
+  var stderr = "";
+  var sessionId = queryOpts.resumeSessionId || null;
+  var model = queryOpts.model || "auto";
+  var effort = queryOpts.effort || null;
+  var toolPolicy = queryOpts.dangerouslySkipPermissions ? "allow-all" : "ask";
+  var blockCounter = 0;
+  var textBlockId = null;
+  var toolBlocks = {};
+  var latestUsage = null;
+  var firstMessage = true;
+
+  function notifyFinished() {
+    if (finished) return;
+    finished = true;
+    if (typeof onFinished === "function") onFinished();
+  }
+
+  function pushEvent(event) {
+    if (ended) return;
+    if (eventWaiter) {
+      var resolve = eventWaiter;
+      eventWaiter = null;
+      resolve({ value: event, done: false });
+    } else {
+      events.push(event);
+    }
+  }
+
+  function endEvents() {
+    if (ended) return;
+    ended = true;
+    if (eventWaiter) {
+      var resolve = eventWaiter;
+      eventWaiter = null;
+      resolve({ value: undefined, done: true });
+    }
+    notifyFinished();
+  }
+
+  function buildPrompt(text, images) {
+    var prompt = text || "";
+    if (firstMessage) {
+      var systemParts = [queryOpts.systemPrompt, queryOpts.appendSystemPrompt].filter(function(part) { return !!part; });
+      if (systemParts.length) prompt = systemParts.join("\n\n") + "\n\n" + prompt;
+      firstMessage = false;
+    }
+    if (images && images.length) {
+      prompt += "\n\n[Clay could not forward " + images.length + " attached image(s) because Antigravity CLI stream input currently accepts text only.]";
+    }
+    return prompt;
+  }
+
+  function writeNextMessage() {
+    if (!processHandle || !processHandle.stdin || activeTurn || !messages.length) return;
+    activeTurn = true;
+    textBlockId = null;
+    toolBlocks = {};
+    pushEvent({ yokeType: "turn_start", messageType: "user" });
+    processHandle.stdin.write(JSON.stringify({
+      event: "user",
+      message: { content: messages.shift() },
+    }) + "\n");
+  }
+
+  function finishTurn(result) {
+    result = result || {};
+    if (result.conversation_id) sessionId = result.conversation_id;
+    if (result.usage) latestUsage = result.usage;
+    var status = result.status || "SUCCESS";
+    if (status !== "SUCCESS") {
+      if (status === "CANCELED" || status === "INTERRUPTED") {
+        pushEvent({ yokeType: "interrupted" });
+      } else {
+        var errorText = result.error || "Antigravity CLI ended the turn with status " + status;
+        pushEvent(isAuthError(errorText)
+          ? { yokeType: "auth_required", vendor: "antigravity" }
+          : { yokeType: "error", text: errorText });
+      }
+    }
+    pushEvent({
+      yokeType: "result",
+      messageType: "assistant",
+      cost: null,
+      duration: typeof result.duration_seconds === "number" ? result.duration_seconds * 1000 : null,
+      usage: latestUsage ? {
+        input_tokens: latestUsage.input_tokens || 0,
+        output_tokens: latestUsage.output_tokens || 0,
+        cache_read_input_tokens: latestUsage.cache_read_tokens || 0,
+        cache_creation_input_tokens: 0,
+      } : null,
+      sessionId: sessionId,
+      lastStreamInputTokens: latestUsage ? latestUsage.input_tokens : null,
+    });
+    activeTurn = false;
+    if (messages.length) writeNextMessage();
+    else if (inputEnded && processHandle && processHandle.stdin) processHandle.stdin.end();
+  }
+
+  function handleStep(step) {
+    if (!step) return;
+    if (step.step_type === "agent_response") {
+      if (!textBlockId) {
+        textBlockId = "agy_blk_" + (++blockCounter);
+        pushEvent({ yokeType: "text_start", blockId: textBlockId });
+      }
+      if (step.text_delta) pushEvent({ yokeType: "text_delta", blockId: textBlockId, text: step.text_delta });
+      return;
+    }
+    if (step.step_type !== "tool") return;
+    var info = step.tool_info || {};
+    var id = "agy_tool_" + step.step_index;
+    var name = toolName(step.tool_name || info.name);
+    if (!toolBlocks[id]) {
+      toolBlocks[id] = "agy_blk_" + (++blockCounter);
+      pushEvent({ yokeType: "tool_start", blockId: toolBlocks[id], toolId: id, toolName: name });
+      pushEvent({ yokeType: "tool_executing", blockId: toolBlocks[id], toolId: id, toolName: name, input: info.parameters || {} });
+    }
+    if (step.state === "DONE") {
+      var error = info.error;
+      pushEvent({
+        yokeType: "tool_result",
+        blockId: toolBlocks[id],
+        toolId: id,
+        content: error ? (error.message || String(error)) : (info.output || ""),
+        isError: !!error,
+      });
+    }
+  }
+
+  function handleOutput(line) {
+    var event;
+    try { event = JSON.parse(line); } catch (e) { return; }
+    if (event.event === "init") {
+      sessionId = event.conversation_id || (event.init && event.init.conversation_id) || sessionId;
+      return;
+    }
+    if (event.event === "step_update") {
+      handleStep(event.step_update);
+      return;
+    }
+    if (event.event === "result") finishTurn(event.result);
+  }
+
+  function start() {
+    if (started || ended) return;
+    started = true;
+    var args = ["--input-format", "stream-json", "--output-format", "stream-json"];
+    if (sessionId) args.push("--conversation", sessionId);
+    if (model && model !== "auto") args.push("--model", model);
+    if (effort) args.push("--effort", effort);
+    if (toolPolicy === "allow-all") args.push("--dangerously-skip-permissions");
+    var spawnProcess = queryOpts._spawn || childProcess.spawn;
+    processHandle = spawnProcess(binaryPath, args, {
+      cwd: queryOpts.cwd || process.cwd(),
+      env: Object.assign({}, process.env, queryOpts.env || {}),
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    outputReader = readline.createInterface({ input: processHandle.stdout });
+    outputReader.on("line", handleOutput);
+    processHandle.stderr.on("data", function(chunk) {
+      stderr += String(chunk);
+      if (stderr.length > 65536) stderr = stderr.slice(-65536);
+    });
+    processHandle.on("error", function(err) {
+      pushEvent({ yokeType: "error", text: "Failed to start Antigravity CLI: " + err.message });
+      endEvents();
+    });
+    processHandle.on("exit", function(code, signal) {
+      if (!ended && activeTurn) {
+        var message = stderr.trim() || "Antigravity CLI exited before completing the turn";
+        pushEvent(isAuthError(message)
+          ? { yokeType: "auth_required", vendor: "antigravity" }
+          : { yokeType: "error", text: message + (code ? " (exit " + code + ")" : signal ? " (" + signal + ")" : "") });
+      }
+      endEvents();
+    });
+    writeNextMessage();
+  }
+
+  var handle = {
+    [Symbol.asyncIterator]: function() {
+      return {
+        next: function() {
+          if (events.length) return Promise.resolve({ value: events.shift(), done: false });
+          if (ended) return Promise.resolve({ value: undefined, done: true });
+          return new Promise(function(resolve) { eventWaiter = resolve; });
+        },
+      };
+    },
+    pushMessage: function(text, images) {
+      if (ended || inputEnded) return false;
+      messages.push(buildPrompt(text, images));
+      if (!started) start();
+      else writeNextMessage();
+      return true;
+    },
+    setModel: function(value) {
+      if (started) return Promise.reject(new Error("Antigravity CLI cannot switch models after a streaming session starts"));
+      model = value || "auto";
+      return Promise.resolve();
+    },
+    setEffort: function(value) {
+      if (started) return Promise.reject(new Error("Antigravity CLI cannot switch effort after a streaming session starts"));
+      effort = value || null;
+      return Promise.resolve();
+    },
+    setToolPolicy: function(policy) {
+      if (started) return Promise.reject(new Error("Antigravity CLI cannot switch tool policy after a streaming session starts"));
+      toolPolicy = policy === "allow-all" ? "allow-all" : "ask";
+      return Promise.resolve();
+    },
+    stopTask: function() { return Promise.resolve(); },
+    getContextUsage: function() {
+      if (!latestUsage) return Promise.resolve(null);
+      return Promise.resolve({
+        input_tokens: (latestUsage.input_tokens || 0) + (latestUsage.cache_read_tokens || 0),
+        contextWindow: null,
+      });
+    },
+    endInput: function() {
+      inputEnded = true;
+      if (!activeTurn && processHandle && processHandle.stdin) processHandle.stdin.end();
+    },
+    abort: function() {
+      if (ended) return;
+      pushEvent({ yokeType: "interrupted" });
+      if (processHandle) processHandle.kill("SIGINT");
+      endEvents();
+    },
+    close: function() {
+      inputEnded = true;
+      if (processHandle && processHandle.stdin) processHandle.stdin.end();
+      endEvents();
+    },
+  };
+  return handle;
+}
+
+function createAntigravityAdapter(opts) {
+  opts = opts || {};
+  var cwd = opts.cwd || process.cwd();
+  var binaryPath = opts._binaryPath || null;
+  var cachedModels = ["auto"];
+  var activeHandles = [];
+
+  function capabilities() {
+    return {
+      effort: true,
+      midSessionModelSwitch: false,
+      fork: false,
+      rollback: false,
+      sessionListing: false,
+      sessionRename: false,
+      thinking: false,
+      betas: false,
+      rewind: false,
+      sessionResume: true,
+      promptSuggestions: false,
+      elicitation: false,
+      fileCheckpointing: false,
+      contextCompacting: false,
+      skillSharing: true,
+      toolPolicy: ["ask", "allow-all"],
+    };
+  }
+
+  var adapter = {
+    vendor: "antigravity",
+    init: async function() {
+      if (!binaryPath) binaryPath = findBinary();
+      if (!binaryPath) throw new Error("Antigravity CLI binary not found: agy");
+      var fetched = opts._fetchModels ? await opts._fetchModels(binaryPath, cwd) : await fetchModels(binaryPath, cwd);
+      if (fetched && fetched.length) cachedModels = fetched;
+      var skills = skillDiscovery.discoverSkills(cwd).map(function(skill) { return skill.name; });
+      return {
+        models: cachedModels.slice(),
+        defaultModel: cachedModels[0] || "auto",
+        skills: skills,
+        slashCommands: skills,
+        fastModeState: null,
+        capabilities: capabilities(),
+      };
+    },
+    supportedModels: function() { return Promise.resolve(cachedModels.slice()); },
+    createToolServer: function() { return null; },
+    createQuery: async function(queryOpts) {
+      if (!binaryPath) await adapter.init();
+      queryOpts = queryOpts || {};
+      var antigravityOpts = (queryOpts.adapterOptions && queryOpts.adapterOptions.ANTIGRAVITY) || {};
+      var handle;
+      handle = createAntigravityQueryHandle(binaryPath, Object.assign({}, queryOpts, {
+        dangerouslySkipPermissions: !!antigravityOpts.dangerouslySkipPermissions,
+        env: antigravityOpts.env || null,
+        _spawn: opts._spawn || null,
+      }), function() {
+        var index = activeHandles.indexOf(handle);
+        if (index !== -1) activeHandles.splice(index, 1);
+      });
+      activeHandles.push(handle);
+      return handle;
+    },
+    generateTitle: async function(messages, titleOpts) {
+      var handle = await adapter.createQuery({
+        cwd: (titleOpts && titleOpts.cwd) || cwd,
+        systemPrompt: "Generate a concise conversation title of 3 to 8 words. Output only the title.",
+      });
+      var prompt = messages.join("\n");
+      var title = "";
+      handle.pushMessage(prompt);
+      handle.endInput();
+      for await (var event of handle) {
+        if (event.yokeType === "text_delta") title += event.text;
+      }
+      return title.trim().replace(/^['\"]|['\"]$/g, "").slice(0, 80) || "New conversation";
+    },
+    shutdown: function() {
+      var handles = activeHandles.slice();
+      for (var i = 0; i < handles.length; i++) handles[i].abort();
+      activeHandles = [];
+      return Promise.resolve(true);
+    },
+  };
+  return adapter;
+}
+
+module.exports = {
+  createAntigravityAdapter: createAntigravityAdapter,
+  createAntigravityQueryHandle: createAntigravityQueryHandle,
+  fetchModels: fetchModels,
+  parseModels: parseModels,
+};