@smithers-orchestrator/agents 0.20.4 → 0.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithers-orchestrator/agents",
-  "version": "0.20.4",
+  "version": "0.22.0",
   "description": "AI SDK and CLI agent adapters for Smithers",
   "type": "module",
   "sideEffects": false,
@@ -50,9 +50,9 @@
     "ai": "^6.0.168",
     "effect": "^3.21.1",
     "zod": "^4.3.6",
-    "@smithers-orchestrator/errors": "0.20.4",
-    "@smithers-orchestrator/driver": "0.20.4",
-    "@smithers-orchestrator/observability": "0.20.4"
+    "@smithers-orchestrator/driver": "0.22.0",
+    "@smithers-orchestrator/errors": "0.22.0",
+    "@smithers-orchestrator/observability": "0.22.0"
   },
   "devDependencies": {
     "@types/bun": "latest",
@@ -60,7 +60,7 @@
     "typescript": "~5.9.3"
   },
   "scripts": {
-    "test": "bun test tests",
+    "test": "bun test --timeout=60000 --max-concurrency=1 tests",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "build": "tsup --dts-only"
   }

package/src/AntigravityAgent.js

@@ -0,0 +1,267 @@
+import { BaseCliAgent, pushFlag, pushList, isRecord, asString, truncate, toolKindFromName, createSyntheticIdGenerator, } from "./BaseCliAgent/index.js";
+import { normalizeCapabilityStringList, } from "./capability-registry/index.js";
+/** @typedef {import("./capability-registry/AgentCapabilityRegistry.ts").AgentCapabilityRegistry} AgentCapabilityRegistry */
+/** @typedef {import("./BaseCliAgent/CliOutputInterpreter.ts").CliOutputInterpreter} CliOutputInterpreter */
+/** @typedef {import("./AntigravityAgentOptions.ts").AntigravityAgentOptions} AntigravityAgentOptions */
+
+/**
+ * @param {AntigravityAgentOptions} opts
+ */
+function resolveAntigravityBuiltIns(opts) {
+    return opts.allowedTools?.length
+        ? normalizeCapabilityStringList(opts.allowedTools)
+        : ["default"];
+}
+
+/**
+ * @param {AntigravityAgentOptions} [opts]
+ * @returns {AgentCapabilityRegistry}
+ */
+export function createAntigravityCapabilityRegistry(opts = {}) {
+    return {
+        version: 1,
+        engine: "antigravity",
+        runtimeTools: {},
+        mcp: {
+            bootstrap: "project-config",
+            supportsProjectScope: true,
+            supportsUserScope: true,
+        },
+        skills: {
+            supportsSkills: true,
+            installMode: "plugin",
+            smithersSkillIds: [],
+        },
+        humanInteraction: {
+            supportsUiRequests: false,
+            methods: [],
+        },
+        builtIns: resolveAntigravityBuiltIns(opts),
+    };
+}
+
+export class AntigravityAgent extends BaseCliAgent {
+    opts;
+    capabilities;
+    cliEngine = "antigravity";
+    /**
+   * @param {AntigravityAgentOptions} [opts]
+   */
+    constructor(opts = {}) {
+        super(opts);
+        this.opts = opts;
+        this.capabilities = createAntigravityCapabilityRegistry(opts);
+    }
+    /**
+   * @returns {CliOutputInterpreter}
+   */
+    createOutputInterpreter() {
+        let sessionId;
+        let finalAnswer = "";
+        let didEmitCompleted = false;
+        const nextSyntheticId = createSyntheticIdGenerator();
+        /**
+     * @param {string} line
+     * @returns {AgentCliEvent[]}
+     */
+        const parseLine = (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return [];
+            let payload;
+            try {
+                payload = JSON.parse(trimmed);
+            }
+            catch {
+                return [];
+            }
+            if (!isRecord(payload))
+                return [];
+            const type = asString(payload.type);
+            if (!type)
+                return [];
+            if (type === "init") {
+                const resume = asString(payload.session_id);
+                if (resume) {
+                    sessionId = resume;
+                }
+                return [{
+                        type: "started",
+                        engine: this.cliEngine,
+                        title: "Antigravity CLI",
+                        resume: sessionId,
+                        detail: {
+                            model: asString(payload.model),
+                        },
+                    }];
+            }
+            if (type === "MESSAGE") {
+                const role = asString(payload.role);
+                const content = asString(payload.content);
+                if (role === "assistant" && content) {
+                    if (payload.delta === true) {
+                        finalAnswer += content;
+                    }
+                    else {
+                        finalAnswer = content;
+                    }
+                }
+                return [];
+            }
+            if (type === "TOOL_USE") {
+                const toolName = asString(payload.tool_name) ?? "tool";
+                const toolId = asString(payload.tool_id) ?? nextSyntheticId("antigravity-tool");
+                return [{
+                        type: "action",
+                        engine: this.cliEngine,
+                        phase: "started",
+                        entryType: "thought",
+                        action: {
+                            id: toolId,
+                            kind: toolKindFromName(toolName),
+                            title: toolName,
+                            detail: {
+                                parameters: payload.parameters,
+                            },
+                        },
+                        message: `Running ${toolName}`,
+                        level: "info",
+                    }];
+            }
+            if (type === "TOOL_RESULT") {
+                const toolId = asString(payload.tool_id) ?? nextSyntheticId("antigravity-tool");
+                const ok = asString(payload.status) !== "error";
+                const error = isRecord(payload.error) ? asString(payload.error.message) : undefined;
+                const output = asString(payload.output);
+                return [{
+                        type: "action",
+                        engine: this.cliEngine,
+                        phase: "completed",
+                        entryType: "thought",
+                        action: {
+                            id: toolId,
+                            kind: "tool",
+                            title: "tool result",
+                            detail: {
+                                status: asString(payload.status),
+                                output: output ? truncate(output, 400) : undefined,
+                            },
+                        },
+                        message: error ?? output,
+                        ok,
+                        level: ok ? "info" : "warning",
+                    }];
+            }
+            if (type === "ERROR") {
+                return [{
+                        type: "action",
+                        engine: this.cliEngine,
+                        phase: "completed",
+                        entryType: "thought",
+                        action: {
+                            id: nextSyntheticId("antigravity-warning"),
+                            kind: "warning",
+                            title: "warning",
+                            detail: {
+                                severity: asString(payload.severity),
+                            },
+                        },
+                        message: asString(payload.message),
+                        ok: asString(payload.severity) !== "error",
+                        level: asString(payload.severity) === "error" ? "error" : "warning",
+                    }];
+            }
+            if (type === "RESULT") {
+                if (didEmitCompleted)
+                    return [];
+                didEmitCompleted = true;
+                return [{
+                        type: "completed",
+                        engine: this.cliEngine,
+                        ok: asString(payload.status) !== "error",
+                        answer: finalAnswer || asString(payload.response),
+                        resume: sessionId,
+                        usage: isRecord(payload.stats) ? payload.stats : undefined,
+                    }];
+            }
+            return [];
+        };
+        return {
+            onStdoutLine: parseLine,
+            onExit: (result) => {
+                if (didEmitCompleted)
+                    return [];
+                if (result.exitCode === 0)
+                    return [];
+                didEmitCompleted = true;
+                return [{
+                        type: "completed",
+                        engine: this.cliEngine,
+                        ok: false,
+                        answer: finalAnswer || undefined,
+                        error: result.stderr.trim() || `Antigravity exited with code ${result.exitCode}`,
+                        resume: sessionId,
+                    }];
+            },
+        };
+    }
+    /**
+   * @param {{ prompt: string; systemPrompt?: string; cwd: string; options: any; }} params
+   */
+    async buildCommand(params) {
+        const args = [];
+        const yoloEnabled = this.opts.dangerouslySkipPermissions ?? this.opts.yolo ?? this.yolo;
+        const outputFormat = this.opts.outputFormat ??
+            (params.options?.onEvent ? "stream-json" : "json");
+        const resumeSession = typeof params.options?.resumeSession === "string"
+            ? params.options.resumeSession
+            : this.opts.resume;
+        if (this.opts.debug)
+            args.push("--debug");
+        pushFlag(args, "--model", this.opts.model ?? this.model);
+        if (this.opts.sandbox)
+            args.push("--sandbox");
+        if (yoloEnabled)
+            args.push("--dangerously-skip-permissions");
+        pushList(args, "--allowed-mcp-server-names", this.opts.allowedMcpServerNames);
+        if (this.opts.allowedTools !== undefined) {
+            if (this.opts.allowedTools.length === 0) {
+                pushFlag(args, "--allowed-tools", "");
+            }
+            else {
+                pushList(args, "--allowed-tools", this.opts.allowedTools);
+            }
+        }
+        pushList(args, "--extensions", this.opts.extensions);
+        if (this.opts.listExtensions)
+            args.push("--list-extensions");
+        pushFlag(args, "--resume", resumeSession);
+        if (this.opts.listSessions)
+            args.push("--list-sessions");
+        pushFlag(args, "--delete-session", this.opts.deleteSession);
+        pushList(args, "--include-directories", this.opts.includeDirectories);
+        if (this.opts.screenReader)
+            args.push("--screen-reader");
+        pushFlag(args, "--gemini_dir", this.opts.geminiDir ?? this.opts.configDir);
+        pushFlag(args, "--output-format", outputFormat);
+        if (this.extraArgs?.length)
+            args.push(...this.extraArgs);
+        const systemPrefix = params.systemPrompt
+            ? `${params.systemPrompt}\n\n`
+            : "";
+        const jsonReminder = params.prompt?.includes("REQUIRED OUTPUT")
+            ? "\n\nREMINDER: Your response MUST be ONLY the required raw JSON object. Do not include prose, markdown, or code fences. The first character must be `{` and the last character must be `}`.\n"
+            : "";
+        const fullPrompt = `${systemPrefix}${params.prompt ?? ""}${jsonReminder}`;
+        args.push("--prompt", fullPrompt);
+        const accountEnv = {};
+        if (this.opts.apiKey)
+            accountEnv.GEMINI_API_KEY = this.opts.apiKey;
+        return {
+            command: this.opts.binary ?? "agy",
+            args,
+            outputFormat,
+            env: Object.keys(accountEnv).length > 0 ? accountEnv : undefined,
+        };
+    }
+}

package/src/AntigravityAgentOptions.ts

@@ -0,0 +1,38 @@
+import type { BaseCliAgentOptions } from "./BaseCliAgent/BaseCliAgentOptions";
+
+export type AntigravityAgentOptions = BaseCliAgentOptions & {
+  debug?: boolean;
+  model?: string;
+  sandbox?: boolean;
+  yolo?: boolean;
+  dangerouslySkipPermissions?: boolean;
+  allowedMcpServerNames?: string[];
+  allowedTools?: string[];
+  extensions?: string[];
+  listExtensions?: boolean;
+  resume?: string;
+  listSessions?: boolean;
+  deleteSession?: string;
+  includeDirectories?: string[];
+  screenReader?: boolean;
+  outputFormat?: "text" | "json" | "stream-json";
+  /**
+   * Antigravity CLI binary to execute. The official CLI currently installs
+   * `agy`; this exists for test harnesses and future binary renames.
+   */
+  binary?: string;
+  /**
+   * Path to an isolated Google CLI config root. Passed as `--gemini_dir` so
+   * Antigravity reads/writes `<configDir>/antigravity-cli/...` instead of the
+   * user's default `~/.gemini/antigravity-cli/...`.
+   */
+  configDir?: string;
+  /**
+   * Explicit alias for `configDir` when matching the Antigravity CLI flag name.
+   */
+  geminiDir?: string;
+  /**
+   * Google API key for API-billed invocations when supported by the CLI.
+   */
+  apiKey?: string;
+};

package/src/BaseCliAgent/BaseCliAgent.js

@@ -458,6 +458,7 @@ export function extractUsageFromOutput(raw) {
     const lines = stripOscSequences(raw).split(/\r?\n/).filter(Boolean);
     const usage = {};
     let found = false;
+    let countedIncremental = false;
     for (const line of lines) {
         let parsed;
         try {
@@ -480,6 +481,7 @@ export function extractUsageFromOutput(raw) {
                     (usage.cacheWriteTokens ?? 0) + u.cache_creation_input_tokens;
             }
             found = true;
+            countedIncremental = true;
             continue;
         }
         if (parsed.type === "message_delta" && parsed.usage) {
@@ -488,8 +490,19 @@ export function extractUsageFromOutput(raw) {
                     (usage.outputTokens ?? 0) + parsed.usage.output_tokens;
             }
             found = true;
+            countedIncremental = true;
             continue;
         }
+        if (parsed.type === "result") {
+            // Claude Code stream-json emits a terminal "result" event whose
+            // top-level usage summarizes tokens already accumulated from the
+            // per-message message_start/message_delta events. If we counted
+            // those incrementally, skip this event to avoid double-counting.
+            // Otherwise fall through so the usage is still captured.
+            if (countedIncremental) {
+                continue;
+            }
+        }
         if (parsed.type === "turn.completed" && parsed.usage) {
             const u = parsed.usage;
             if (u.input_tokens) {

package/src/BaseCliAgent/runRpcCommandEffect.js

@@ -13,7 +13,7 @@ import { truncateToBytes } from "./truncateToBytes.js";
 
 /** @typedef {import("./PiExtensionUiRequest.ts").PiExtensionUiRequest} PiExtensionUiRequest */
 /**
- * @typedef {{ cwd: string; env: Record<string, string>; prompt: string; timeoutMs?: number; idleTimeoutMs?: number; signal?: AbortSignal; maxOutputBytes?: number; onStdout?: (chunk: string) => void; onStderr?: (chunk: string) => void; onJsonEvent?: (event: Record<string, unknown>) => Promise<void> | void; onExtensionUiRequest?: (request: PiExtensionUiRequest) => Promise<PiExtensionUiResponse | null> | PiExtensionUiResponse | null; }} RunRpcCommandOptions
+ * @typedef {{ cwd: string; env: Record<string, string>; prompt: string; timeoutMs?: number; idleTimeoutMs?: number; signal?: AbortSignal; maxOutputBytes?: number; onStdout?: (chunk: string) => void; onStderr?: (chunk: string) => void; onJsonEvent?: (event: Record<string, unknown>) => Promise<void> | void; onExtensionUiRequest?: (request: PiExtensionUiRequest) => Promise<PiExtensionUiResponse | null> | PiExtensionUiResponse | null; spawnFn?: typeof spawn; }} RunRpcCommandOptions
  */
 
 /**
@@ -61,7 +61,7 @@ function createInactivityTimer(timeoutMs, onTimeout) {
  * @returns {Effect.Effect<{ text: string; output: unknown; stderr: string; exitCode: number | null; usage?: any; }, SmithersError>}
  */
 export function runRpcCommandEffect(command, args, options) {
-    const { cwd, env, prompt, timeoutMs, idleTimeoutMs, signal, maxOutputBytes, onStdout, onStderr, onJsonEvent, onExtensionUiRequest, } = options;
+    const { cwd, env, prompt, timeoutMs, idleTimeoutMs, signal, maxOutputBytes, onStdout, onStderr, onJsonEvent, onExtensionUiRequest, spawnFn = spawn, } = options;
     const span = `agent:${command}:rpc`;
     const logAnnotations = {
         agentCommand: command,
@@ -82,7 +82,7 @@ export function runRpcCommandEffect(command, args, options) {
         let extractedUsage = undefined;
         let stderrTruncated = false;
         logDebug("starting agent RPC command", logAnnotations, span);
-        const child = spawn(command, args, {
+        const child = spawnFn(command, args, {
             cwd,
             env,
             detached: true,
@@ -108,6 +108,8 @@ export function runRpcCommandEffect(command, args, options) {
             if (settled)
                 return;
             settled = true;
+            inactivity.clear();
+            totalTimeout.clear();
             if (signal) {
                 signal.removeEventListener("abort", onAbort);
             }
@@ -131,6 +133,8 @@ export function runRpcCommandEffect(command, args, options) {
             if (settled)
                 return;
             settled = true;
+            inactivity.clear();
+            totalTimeout.clear();
             if (signal) {
                 signal.removeEventListener("abort", onAbort);
             }

package/src/BaseCliAgent/truncateToBytes.js

@@ -9,5 +9,22 @@ export function truncateToBytes(text, maxBytes) {
     const buf = Buffer.from(text, "utf8");
     if (buf.length <= maxBytes)
         return text;
-    return buf.subarray(0, maxBytes).toString("utf8");
+    let end = maxBytes;
+    // Back off any UTF-8 continuation bytes (0b10xxxxxx) so the slice ends on a
+    // codepoint boundary, then drop the lead byte if its sequence is incomplete.
+    while (end > 0 && (buf[end] & 0xc0) === 0x80)
+        end--;
+    if (end > 0) {
+        const lead = buf[end - 1];
+        let seqLen = 1;
+        if ((lead & 0xe0) === 0xc0)
+            seqLen = 2;
+        else if ((lead & 0xf0) === 0xe0)
+            seqLen = 3;
+        else if ((lead & 0xf8) === 0xf0)
+            seqLen = 4;
+        if ((end - 1) + seqLen > maxBytes)
+            end--;
+    }
+    return buf.subarray(0, end).toString("utf8");
 }

package/src/CodexAgent.js

@@ -510,7 +510,7 @@ export class CodexAgent extends BaseCliAgent {
         const resumeSession = typeof params.options?.resumeSession === "string"
             ? params.options.resumeSession
             : undefined;
-        const args = resumeSession ? ["exec", "resume", resumeSession] : ["exec"];
+        const args = resumeSession ? ["exec", "resume"] : ["exec"];
         const yoloEnabled = this.opts.yolo ?? this.yolo;
         const configOverrides = normalizeCodexConfig(this.opts.config);
         for (const entry of configOverrides) {
@@ -520,21 +520,26 @@ export class CodexAgent extends BaseCliAgent {
         pushList(args, "--disable", this.opts.disable);
         pushList(args, "--image", this.opts.image);
         pushFlag(args, "--model", this.opts.model ?? this.model);
-        if (this.opts.oss)
+        if (!resumeSession && this.opts.oss)
             args.push("--oss");
-        pushFlag(args, "--local-provider", this.opts.localProvider);
-        pushFlag(args, "--sandbox", this.opts.sandbox);
-        pushFlag(args, "--profile", this.opts.profile);
-        if (this.opts.fullAuto) {
+        if (!resumeSession)
+            pushFlag(args, "--local-provider", this.opts.localProvider);
+        if (!resumeSession)
+            pushFlag(args, "--sandbox", this.opts.sandbox);
+        if (!resumeSession)
+            pushFlag(args, "--profile", this.opts.profile);
+        if (!resumeSession && this.opts.fullAuto) {
             args.push("--full-auto");
         }
         else if (yoloEnabled || this.opts.dangerouslyBypassApprovalsAndSandbox) {
             args.push("--dangerously-bypass-approvals-and-sandbox");
         }
-        pushFlag(args, "--cd", this.opts.cd);
+        if (!resumeSession)
+            pushFlag(args, "--cd", this.opts.cd);
         if (this.opts.skipGitRepoCheck)
             args.push("--skip-git-repo-check");
-        pushList(args, "--add-dir", this.opts.addDir);
+        if (!resumeSession)
+            pushList(args, "--add-dir", this.opts.addDir);
         if (!resumeSession) {
             pushFlag(args, "--output-schema", this.opts.outputSchema);
         }
@@ -562,6 +567,8 @@ export class CodexAgent extends BaseCliAgent {
         pushFlag(args, "--output-last-message", outputFile);
         if (this.extraArgs?.length)
             args.push(...this.extraArgs);
+        if (resumeSession)
+            args.push(resumeSession);
         const systemPrefix = params.systemPrompt
             ? `${params.systemPrompt}\n\n`
             : "";

package/src/GeminiAgent.js

@@ -38,6 +38,10 @@ export function createGeminiCapabilityRegistry(opts = {}) {
         builtIns: resolveGeminiBuiltIns(opts),
     };
 }
+/**
+ * @deprecated Use AntigravityAgent for new Google CLI integrations. GeminiAgent
+ * remains for legacy and enterprise Gemini CLI setups.
+ */
 export class GeminiAgent extends BaseCliAgent {
     opts;
     capabilities;

package/src/GeminiAgentOptions.ts

@@ -1,5 +1,10 @@
 import type { BaseCliAgentOptions } from "./BaseCliAgent/BaseCliAgentOptions";
 
+/**
+ * @deprecated Use AntigravityAgentOptions with the Antigravity CLI (`agy`) for
+ * new Google CLI integrations. GeminiAgentOptions remains for legacy and
+ * enterprise Gemini CLI setups.
+ */
 export type GeminiAgentOptions = BaseCliAgentOptions & {
   debug?: boolean;
   model?: string;

package/src/HermesAgent.js

@@ -0,0 +1,41 @@
+import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
+import { OpenAIAgent } from "./OpenAIAgent.js";
+
+/**
+ * @template [CALL_OPTIONS=never], [TOOLS=import("ai").ToolSet]
+ * @typedef {import("./HermesAgentOptions.ts").HermesAgentOptions<CALL_OPTIONS, TOOLS>} HermesAgentOptions
+ */
+
+/**
+ * Hermes (Nous Research) agent, reached over its OpenAI-compatible HTTP API.
+ *
+ * A thin wrapper over {@link OpenAIAgent}: it points the OpenAI-compatible
+ * provider at the Hermes server (`baseURL` / `HERMES_BASE_URL`) and disables AI
+ * SDK native structured output by default, since a local Hermes server may not
+ * honor JSON-schema response formats. Everything else — tool loops, streaming,
+ * prompt-based structured output — comes from the shared OpenAI path.
+ *
+ * @template [CALL_OPTIONS=never], [TOOLS=import("ai").ToolSet]
+ */
+export class HermesAgent extends OpenAIAgent {
+  /**
+   * @param {HermesAgentOptions<CALL_OPTIONS, TOOLS>} [opts]
+   */
+  constructor(opts = {}) {
+    const {
+      model = "hermes",
+      baseURL = process.env.HERMES_BASE_URL,
+      apiKey = process.env.HERMES_API_KEY ?? "hermes",
+      nativeStructuredOutput = false,
+      ...rest
+    } = opts;
+    if (baseURL === undefined) {
+      throw new SmithersError(
+        "AGENT_CONFIG_INVALID",
+        "HermesAgent requires a baseURL (or the HERMES_BASE_URL env var) pointing at the Hermes OpenAI-compatible API, e.g. http://127.0.0.1:5123/v1.",
+        {},
+      );
+    }
+    super({ ...rest, model, baseURL, apiKey, nativeStructuredOutput });
+  }
+}

package/src/HermesAgentOptions.ts

@@ -0,0 +1,41 @@
+import type { openai } from "@ai-sdk/openai";
+import type { ToolSet } from "ai";
+import type { SdkAgentOptions } from "./SdkAgentOptions";
+
+/**
+ * Options for {@link HermesAgent}.
+ *
+ * Hermes (Nous Research) exposes an OpenAI-compatible HTTP API
+ * (`/v1/chat/completions`), so a Hermes agent is reached the same way as any
+ * OpenAI-compatible endpoint: point `baseURL` at the Hermes server. These mirror
+ * the string-model form of `OpenAIAgentOptions`.
+ */
+export type HermesAgentOptions<
+  CALL_OPTIONS = never,
+  TOOLS extends ToolSet = {},
+> = Omit<
+  SdkAgentOptions<CALL_OPTIONS, TOOLS, ReturnType<typeof openai>>,
+  "model"
+> & {
+  /**
+   * Model name exposed by your Hermes server. Defaults to `"hermes"`; override
+   * with whatever model id the server advertises.
+   */
+  model?: string;
+  /**
+   * Base URL of the Hermes OpenAI-compatible API, e.g. `http://127.0.0.1:5123/v1`.
+   * Falls back to the `HERMES_BASE_URL` environment variable.
+   */
+  baseURL?: string;
+  /**
+   * API key sent to the Hermes server. Falls back to `HERMES_API_KEY`, then
+   * `"hermes"` (local servers commonly ignore the value).
+   */
+  apiKey?: string;
+  /**
+   * Enable AI SDK native structured output. Off by default because a local
+   * Hermes server may not honor JSON-schema response formats — leaving it off
+   * makes Smithers fall back to prompt-based JSON extraction.
+   */
+  nativeStructuredOutput?: boolean;
+};

package/src/__type-tests__/AgentLike.assignability.test-d.ts

@@ -1,6 +1,7 @@
 import type {
   AgentLike,
   AmpAgent,
+  AntigravityAgent,
   AnthropicAgent,
   ClaudeCodeAgent,
   CodexAgent,
@@ -20,6 +21,7 @@ type _CustomNativeStructuredAgent = AssertAssignable<{
 
 type _ConcreteAgentsAreAgentLike = [
   AssertAssignable<AmpAgent>,
+  AssertAssignable<AntigravityAgent>,
   AssertAssignable<AnthropicAgent>,
   AssertAssignable<ClaudeCodeAgent>,
   AssertAssignable<CodexAgent>,

package/src/capability-registry/AgentCapabilityRegistry.ts

@@ -2,7 +2,7 @@ import type { AgentToolDescriptor } from "./AgentToolDescriptor";
 
 export type AgentCapabilityRegistry = {
   version: 1;
-  engine: "claude-code" | "codex" | "gemini" | "kimi" | "pi" | "amp" | "forge" | "opencode";
+  engine: "claude-code" | "codex" | "antigravity" | "gemini" | "kimi" | "pi" | "amp" | "forge" | "opencode";
   runtimeTools: Record<string, AgentToolDescriptor>;
   mcp: {
     bootstrap: "inline-config" | "project-config" | "allow-list" | "unsupported";

package/src/cli-capabilities/CliAgentCapabilityAdapterId.ts

@@ -1,5 +1,6 @@
 export type CliAgentCapabilityAdapterId =
   | "claude"
+  | "antigravity"
   | "codex"
   | "gemini"
   | "kimi"

package/src/cli-capabilities/getCliAgentCapabilityReport.js

@@ -1,4 +1,5 @@
 import { hashCapabilityRegistry, normalizeCapabilityRegistry, } from "../capability-registry/index.js";
+import { createAntigravityCapabilityRegistry } from "../AntigravityAgent.js";
 import { createClaudeCodeCapabilityRegistry } from "../ClaudeCodeAgent.js";
 import { createCodexCapabilityRegistry } from "../CodexAgent.js";
 import { createGeminiCapabilityRegistry } from "../GeminiAgent.js";
@@ -18,6 +19,11 @@ const CLI_AGENT_CAPABILITY_ADAPTERS = [
         binary: "codex",
         buildRegistry: () => createCodexCapabilityRegistry(),
     },
+    {
+        id: "antigravity",
+        binary: "agy",
+        buildRegistry: () => createAntigravityCapabilityRegistry(),
+    },
     {
         id: "gemini",
         binary: "gemini",

package/src/diagnostics/getDiagnosticStrategy.js

@@ -321,7 +321,7 @@ const codexStrategy = {
     ],
 };
 // ---------------------------------------------------------------------------
-// Gemini strategy
+// Google CLI strategies
 // ---------------------------------------------------------------------------
 // Validate Google auth via GET /v1beta/models (free, no tokens)
 const googleAuthCheck = {
@@ -438,6 +438,37 @@ const geminiStrategy = {
         googleRateLimitCheck,
     ],
 };
+const antigravityAuthSkip = {
+    id: "api_key_valid",
+    run: async () => {
+        return {
+            id: "api_key_valid",
+            status: "skip",
+            message: "Antigravity CLI uses Google Sign-In/keyring auth; run `agy` to authenticate.",
+            durationMs: 0,
+        };
+    },
+};
+const antigravityRateLimitSkip = {
+    id: "rate_limit_status",
+    run: async () => {
+        return {
+            id: "rate_limit_status",
+            status: "skip",
+            message: "Antigravity CLI rate limits are checked by the CLI at runtime.",
+            durationMs: 0,
+        };
+    },
+};
+const antigravityStrategy = {
+    agentId: "antigravity",
+    command: "agy",
+    checks: [
+        checkCliInstalled("agy", "Antigravity CLI"),
+        antigravityAuthSkip,
+        antigravityRateLimitSkip,
+    ],
+};
 // ---------------------------------------------------------------------------
 // Pi strategy
 // ---------------------------------------------------------------------------
@@ -490,6 +521,8 @@ const ampStrategy = {
 const strategies = {
     claude: claudeStrategy,
     codex: codexStrategy,
+    antigravity: antigravityStrategy,
+    agy: antigravityStrategy,
     gemini: geminiStrategy,
     pi: piStrategy,
     amp: ampStrategy,

package/src/diagnostics/runDiagnostics.js

@@ -19,10 +19,15 @@ const PER_CHECK_TIMEOUT_MS = 5_000;
  */
 async function runCheck(check, ctx) {
     const start = performance.now();
+    /** @type {ReturnType<typeof setTimeout> | undefined} */
+    let timeoutHandle;
     try {
         return await Promise.race([
             check.run(ctx),
-            new Promise((_, reject) => setTimeout(() => reject(new SmithersError("AGENT_DIAGNOSTIC_TIMEOUT", "diagnostic check timed out", { timeoutMs: PER_CHECK_TIMEOUT_MS })), PER_CHECK_TIMEOUT_MS)),
+            new Promise((_, reject) => {
+                timeoutHandle = setTimeout(() => reject(new SmithersError("AGENT_DIAGNOSTIC_TIMEOUT", "diagnostic check timed out", { timeoutMs: PER_CHECK_TIMEOUT_MS })), PER_CHECK_TIMEOUT_MS);
+                timeoutHandle.unref?.();
+            }),
         ]);
     }
     catch (err) {
@@ -33,6 +38,9 @@ async function runCheck(check, ctx) {
             durationMs: performance.now() - start,
         };
     }
+    finally {
+        clearTimeout(timeoutHandle);
+    }
 }
 /**
  * @param {AgentDiagnosticStrategy} strategy

package/src/index.d.ts

@@ -138,7 +138,7 @@ type AgentToolDescriptor$1 = {
 
 type AgentCapabilityRegistry$3 = {
     version: 1;
-    engine: "claude-code" | "codex" | "gemini" | "kimi" | "pi" | "amp" | "forge" | "opencode";
+    engine: "claude-code" | "codex" | "antigravity" | "gemini" | "kimi" | "pi" | "amp" | "forge" | "opencode";
     runtimeTools: Record<string, AgentToolDescriptor$1>;
     mcp: {
         bootstrap: "inline-config" | "project-config" | "allow-list" | "unsupported";
@@ -364,6 +364,19 @@ declare class OpenAIAgent extends ToolLoopAgent<never, any, never> {
 type GenerateTextResult$1 = ai.GenerateTextResult<any, any>;
 type OpenAIAgentOptions$1<CALL_OPTIONS = never, TOOLS = ai.ToolSet> = OpenAIAgentOptions$2<CALL_OPTIONS, TOOLS>;
 
+type HermesAgentOptions$2<CALL_OPTIONS = never, TOOLS extends ToolSet = {}> = Omit<SdkAgentOptions<CALL_OPTIONS, TOOLS, ReturnType<typeof openai>>, "model"> & {
+    model?: string;
+    baseURL?: string;
+    apiKey?: string;
+    nativeStructuredOutput?: boolean;
+};
+/**
+ * Hermes (Nous Research) agent, reached over its OpenAI-compatible HTTP API.
+ */
+declare class HermesAgent extends OpenAIAgent {
+    constructor(opts?: HermesAgentOptions$2);
+}
+
 /**
  * Configuration options for the AmpAgent.
  */
@@ -425,6 +438,57 @@ declare class AmpAgent extends BaseCliAgent {
 type AmpAgentOptions = AmpAgentOptions$1;
 type CliOutputInterpreter$6 = CliOutputInterpreter$8;
 
+type AntigravityAgentOptions$1 = BaseCliAgentOptions$1 & {
+    debug?: boolean;
+    model?: string;
+    sandbox?: boolean;
+    yolo?: boolean;
+    dangerouslySkipPermissions?: boolean;
+    allowedMcpServerNames?: string[];
+    allowedTools?: string[];
+    extensions?: string[];
+    listExtensions?: boolean;
+    resume?: string;
+    listSessions?: boolean;
+    deleteSession?: string;
+    includeDirectories?: string[];
+    screenReader?: boolean;
+    outputFormat?: "text" | "json" | "stream-json";
+    binary?: string;
+    configDir?: string;
+    geminiDir?: string;
+    apiKey?: string;
+};
+declare function createAntigravityCapabilityRegistry(opts?: AntigravityAgentOptions): AgentCapabilityRegistry$3;
+declare class AntigravityAgent extends BaseCliAgent {
+    /**
+   * @param {AntigravityAgentOptions} [opts]
+   */
+    constructor(opts?: AntigravityAgentOptions);
+    opts: AntigravityAgentOptions$1;
+    capabilities: AgentCapabilityRegistry$3;
+    cliEngine: string;
+    /**
+   * @returns {CliOutputInterpreter}
+   */
+    createOutputInterpreter(): CliOutputInterpreter$6;
+    /**
+   * @param {{ prompt: string; systemPrompt?: string; cwd: string; options: any; }} params
+   */
+    buildCommand(params: {
+        prompt: string;
+        systemPrompt?: string;
+        cwd: string;
+        options: any;
+    }): Promise<{
+        command: string;
+        args: string[];
+        outputFormat: "text" | "json" | "stream-json";
+        env: Record<string, string> | undefined;
+    }>;
+}
+type AntigravityAgentOptions = AntigravityAgentOptions$1;
+
 type ClaudeCodeAgentOptions$1 = BaseCliAgentOptions$1 & {
     addDir?: string[];
     agent?: string;
@@ -887,6 +951,7 @@ type AgentToolDescriptor = AgentToolDescriptor$1;
 type AnthropicAgentOptions<CALL_OPTIONS = never, TOOLS = ai.ToolSet> = AnthropicAgentOptions$2<CALL_OPTIONS, TOOLS>;
 type OpenCodeAgentOptions = OpenCodeAgentOptions$1;
 type OpenAIAgentOptions<CALL_OPTIONS = never, TOOLS = ai.ToolSet> = OpenAIAgentOptions$2<CALL_OPTIONS, TOOLS>;
+type HermesAgentOptions<CALL_OPTIONS = never, TOOLS = ai.ToolSet> = HermesAgentOptions$2<CALL_OPTIONS, TOOLS>;
 type PiAgentOptions = PiAgentOptions$2;
 type PiExtensionUiRequest = PiExtensionUiRequest$1;
 type PiExtensionUiResponse = PiExtensionUiResponse$1;
@@ -896,4 +961,4 @@ type SmithersAgentToolCategory = SmithersAgentToolCategory$1;
 type SmithersListedTool = SmithersListedTool$2;
 type SmithersToolSurface = SmithersToolSurface$2;
 
-export { type AgentCapabilityRegistry, type AgentGenerateOptions, type AgentLike, type AgentToolDescriptor, AmpAgent, AnthropicAgent, type AnthropicAgentOptions, BaseCliAgent, ClaudeCodeAgent, CodexAgent, ForgeAgent, GeminiAgent, KimiAgent, OpenAIAgent, type OpenAIAgentOptions, OpenCodeAgent, type OpenCodeAgentOptions, PiAgent, type PiAgentOptions, type PiExtensionUiRequest, type PiExtensionUiResponse, type SmithersAgentContract, type SmithersAgentContractTool, type SmithersAgentToolCategory, type SmithersListedTool, type SmithersToolSurface, createSmithersAgentContract, hashCapabilityRegistry, renderSmithersAgentPromptGuidance, sanitizeForOpenAI, zodToOpenAISchema };
+export { type AgentCapabilityRegistry, type AgentGenerateOptions, type AgentLike, type AgentToolDescriptor, AmpAgent, AnthropicAgent, type AnthropicAgentOptions, AntigravityAgent, BaseCliAgent, ClaudeCodeAgent, CodexAgent, ForgeAgent, GeminiAgent, HermesAgent, type HermesAgentOptions, KimiAgent, OpenAIAgent, type OpenAIAgentOptions, OpenCodeAgent, type OpenCodeAgentOptions, PiAgent, type PiAgentOptions, type PiExtensionUiRequest, type PiExtensionUiResponse, type SmithersAgentContract, type SmithersAgentContractTool, type SmithersAgentToolCategory, type SmithersListedTool, type SmithersToolSurface, createAntigravityCapabilityRegistry, createSmithersAgentContract, hashCapabilityRegistry, renderSmithersAgentPromptGuidance, sanitizeForOpenAI, zodToOpenAISchema };

package/src/index.js

@@ -13,6 +13,11 @@
  * @template [TOOLS=import("ai").ToolSet]
  * @typedef {import("./OpenAIAgentOptions.ts").OpenAIAgentOptions<CALL_OPTIONS, TOOLS>} OpenAIAgentOptions
  */
+/**
+ * @template [CALL_OPTIONS=never]
+ * @template [TOOLS=import("ai").ToolSet]
+ * @typedef {import("./HermesAgentOptions.ts").HermesAgentOptions<CALL_OPTIONS, TOOLS>} HermesAgentOptions
+ */
 /** @typedef {import("./PiAgentOptions.ts").PiAgentOptions} PiAgentOptions */
 /** @typedef {import("./BaseCliAgent/PiExtensionUiRequest.ts").PiExtensionUiRequest} PiExtensionUiRequest */
 /** @typedef {import("./BaseCliAgent/PiExtensionUiResponse.ts").PiExtensionUiResponse} PiExtensionUiResponse */
@@ -28,7 +33,9 @@ export { BaseCliAgent } from "./BaseCliAgent/index.js";
 export { hashCapabilityRegistry } from "./capability-registry/index.js";
 export { AnthropicAgent } from "./AnthropicAgent.js";
 export { OpenAIAgent } from "./OpenAIAgent.js";
+export { HermesAgent } from "./HermesAgent.js";
 export { AmpAgent } from "./AmpAgent.js";
+export { AntigravityAgent, createAntigravityCapabilityRegistry } from "./AntigravityAgent.js";
 export { ClaudeCodeAgent } from "./ClaudeCodeAgent.js";
 export { CodexAgent } from "./CodexAgent.js";
 export { GeminiAgent } from "./GeminiAgent.js";