@jini-ai/agent-runtime 0.3.8 → 0.3.10

package/dist/auth.d.ts

@@ -13,11 +13,13 @@ export declare function antigravityAuthGuidance(hostName?: string): string;
 export declare function antigravityQuotaGuidance(): string;
 export declare function reasonixAuthGuidance(hostName?: string): string;
 export declare function claudeAuthGuidance(hostName?: string): string;
+export declare function geminiAuthGuidance(hostName?: string): string;
 export declare function isCursorAuthFailureText(text: string): boolean;
 export declare function isAntigravityAuthFailureText(text: string): boolean;
 export declare function isDeepSeekAuthFailureText(text: string): boolean;
 export declare function isReasonixAuthFailureText(text: string): boolean;
 export declare function isClaudeAuthFailureText(text: string): boolean;
+export declare function isGeminiAuthFailureText(text: string): boolean;
 export declare function classifyAgentAuthFailure(agentId: string, text: string, hostName?: string): AgentAuthProbeResult | null;
 export type AgentServiceFailureCode = 'AGENT_AUTH_REQUIRED' | 'RATE_LIMITED' | 'UPSTREAM_UNAVAILABLE';
 export declare function classifyAgentServiceFailure(text: string): AgentServiceFailureCode | null;

package/dist/auth.js

@@ -55,6 +55,17 @@ function reasonixAuthGuidanceText(hostName) {
 function claudeAuthGuidanceText(hostName) {
     return `Claude Code is installed but is not authenticated. Run \`claude auth login\` or open \`claude\` and complete login in a terminal, then rescan. If ${hostName} was launched outside an interactive shell, your shell rc files (e.g. ~/.zshrc) may not be loaded into its environment.`;
 }
+// Gemini CLI has two distinct sign-in failures, and one fix covers both. With no auth method
+// configured, headless mode exits with "Please set an Auth method in your <settings.json> or
+// specify one of the following environment variables before running: GEMINI_API_KEY,
+// GOOGLE_GENAI_USE_VERTEXAI, GOOGLE_GENAI_USE_GCA". With "Login with Google" on a free / Google AI
+// Pro / Ultra account it dies with `IneligibleTierError: This client is no longer supported for
+// Gemini Code Assist for individuals` (Google stopped serving those tiers on 2026-06-18; API keys,
+// Vertex AI and Code Assist licenses still work). Signing in again cannot fix the second one, so
+// the guidance points at an API key or Antigravity instead of a re-login.
+function geminiAuthGuidanceText(hostName) {
+    return `Gemini CLI is installed but has no usable sign-in. Google no longer serves Gemini CLI's "Login with Google" for free, Google AI Pro or Ultra accounts. Use a Gemini API key instead: run \`gemini\` in a terminal, type /auth, choose "Use Gemini API key", and make GEMINI_API_KEY available to ${hostName}'s process environment (or configure Vertex AI). Google's replacement for individual accounts is Antigravity (\`agy\`), which you can pick here instead.`;
+}
 export function cursorAuthGuidance(hostName = DEFAULT_HOST_NAME) {
     return cursorAuthGuidanceText(hostName);
 }
@@ -73,6 +84,9 @@ export function reasonixAuthGuidance(hostName = DEFAULT_HOST_NAME) {
 export function claudeAuthGuidance(hostName = DEFAULT_HOST_NAME) {
     return claudeAuthGuidanceText(hostName);
 }
+export function geminiAuthGuidance(hostName = DEFAULT_HOST_NAME) {
+    return geminiAuthGuidanceText(hostName);
+}
 export function isCursorAuthFailureText(text) {
     const value = String(text || '');
     if (!value.trim())
@@ -145,6 +159,16 @@ export function isClaudeAuthFailureText(text) {
         /authentication required/i.test(value) ||
         /please (?:sign|log)[ _-]?in/i.test(value));
 }
+export function isGeminiAuthFailureText(text) {
+    const value = String(text || '');
+    if (!value.trim())
+        return false;
+    return (/please set an auth method/i.test(value) ||
+        /IneligibleTierError/.test(value) ||
+        /no longer supported for gemini code assist/i.test(value) ||
+        /error authenticating/i.test(value) ||
+        /api key not valid/i.test(value));
+}
 export function classifyAgentAuthFailure(agentId, text, hostName = DEFAULT_HOST_NAME) {
     if (agentId === 'claude') {
         if (!isClaudeAuthFailureText(text))
@@ -171,6 +195,11 @@ export function classifyAgentAuthFailure(agentId, text, hostName = DEFAULT_HOST_
             return null;
         return { status: 'missing', message: reasonixAuthGuidance(hostName) };
     }
+    if (agentId === 'gemini') {
+        if (!isGeminiAuthFailureText(text))
+            return null;
+        return { status: 'missing', message: geminiAuthGuidance(hostName) };
+    }
     return null;
 }
 // A bare HTTP status number (`500`, `429`, …) is too noisy to trust on its own
@@ -250,7 +279,7 @@ function genericAuthGuidance(agentName, hostName) {
 // regex (e.g. cursor-agent's healthy `status` output mentions "login" in
 // ways the generic matcher would misread). The generic classifier is only a
 // fallback for adapters with no tailored classifier of their own.
-const TAILORED_AUTH_AGENTS = new Set(['claude', 'cursor-agent', 'deepseek', 'antigravity', 'reasonix']);
+const TAILORED_AUTH_AGENTS = new Set(['claude', 'cursor-agent', 'deepseek', 'antigravity', 'reasonix', 'gemini']);
 function hasNonEmptyEnv(env, keys) {
     return keys.some((key) => {
         const value = env[key];

package/dist/defs/auggie.d.ts

@@ -0,0 +1,13 @@
+export declare const auggieAgentDef: {
+    id: string;
+    name: string;
+    bin: string;
+    versionArgs: string[];
+    fetchModels: (resolvedBin: string, env: import("../types.js").RuntimeEnv) => Promise<import("../types.js").RuntimeModelOption[]>;
+    fallbackModels: import("../types.js").RuntimeModelOption[];
+    buildArgs: () => string[];
+    streamFormat: string;
+    externalMcpInjection: "acp-merge";
+    imageDelivery: "native";
+};
+//# sourceMappingURL=auggie.d.ts.map

package/dist/defs/auggie.js

@@ -0,0 +1,30 @@
+/**
+ * @module defs/auggie
+ *
+ * Augment Code's Auggie CLI (`auggie`, npm `@augmentcode/auggie`). Runs over ACP: `auggie --acp`
+ * is the launch command the official ACP registry lists
+ * (<https://github.com/agentclientprotocol/registry>, `auggie/agent.json`). Sign-in is
+ * `auggie login` in a terminal.
+ */
+import { detectAcpModels, DEFAULT_MODEL_OPTION } from './shared.js';
+export const auggieAgentDef = {
+    id: 'auggie',
+    name: 'Auggie CLI',
+    bin: 'auggie',
+    versionArgs: ['--version'],
+    fetchModels: async (resolvedBin, env) => detectAcpModels({
+        bin: resolvedBin,
+        args: ['--acp'],
+        env,
+        timeoutMs: 15_000,
+        defaultModelOption: DEFAULT_MODEL_OPTION,
+    }),
+    fallbackModels: [DEFAULT_MODEL_OPTION],
+    buildArgs: () => ['--acp'],
+    streamFormat: 'acp-json-rpc',
+    externalMcpInjection: 'acp-merge',
+    // ACP's `resource_link` prompt blocks carry images natively for every
+    // `acp-json-rpc` def — see `types.ts#RuntimeAgentDef.imageDelivery`'s doc.
+    imageDelivery: 'native',
+};
+//# sourceMappingURL=auggie.js.map

package/dist/defs/claude.d.ts

@@ -14,6 +14,7 @@ export declare const claudeAgentDef: {
         '--add-dir': string;
         '--effort': string;
         '--append-system-prompt': string;
+        '--setting-sources': string;
     };
     fallbackModels: import("../types.js").RuntimeModelOption[];
     fallbackModelsAssertedAt: string;
@@ -27,6 +28,9 @@ export declare const claudeAgentDef: {
     promptInputFormat: "stream-json";
     streamFormat: string;
     externalMcpInjection: "claude-mcp-json";
+    env: {
+        ENABLE_TOOL_SEARCH: string;
+    };
     systemPromptDelivery: {
         strategy: "append-flag";
         flag: string;

package/dist/defs/claude.js

@@ -108,6 +108,7 @@ export const claudeAgentDef = {
         '--add-dir': 'addDir',
         '--effort': 'effort',
         '--append-system-prompt': 'appendSystemPrompt',
+        '--setting-sources': 'settingSources',
     },
     // `claude` has no list-models subcommand, so the model list is answered from the best source
     // available, in this order:
@@ -238,6 +239,15 @@ export const claudeAgentDef = {
         if (options.allowedTools && options.allowedTools.length > 0) {
             args.push('--allowedTools', ...options.allowedTools);
         }
+        // See `RuntimeBuildOptions.settingSources`. Probe-gated like `--effort`: an older build
+        // rejects an unknown option with exit 1, which would kill the chat rather than degrade it.
+        if (options.settingSources !== undefined && caps.settingSources) {
+            args.push('--setting-sources', options.settingSources.join(','));
+        }
+        // See `RuntimeBuildOptions.settings`. Not probe-gated: `--settings` long predates `--setting-sources`.
+        if (options.settings) {
+            args.push('--settings', options.settings);
+        }
         return args;
     },
     promptViaStdin: true,
@@ -247,6 +257,14 @@ export const claudeAgentDef = {
     // so the daemon writes the user's external MCP servers there before
     // launching (server.ts handles the cwd guard).
     externalMcpInjection: 'claude-mcp-json',
+    // Load MCP tools up front instead of deferring them behind the CLI's ToolSearch tool.
+    // Deferral cost every run one extra model round (a `select:` ToolSearch call, ~3 s) before its
+    // first real tool call, while the run's MCP set is only what the daemon stages
+    // (`--strict-mcp-config`; 11 tools for the Tovu host), so loading it eagerly is cheap. Documented at
+    // code.claude.com/docs/en/mcp ("`false` — All MCP tools loaded upfront, no deferral"); verified
+    // in the installed 2.1.283 binary (a defined-falsy value selects the "standard" tool mode).
+    // A default only: a run's own env can still set ENABLE_TOOL_SEARCH (see agent-executor).
+    env: { ENABLE_TOOL_SEARCH: 'false' },
     // Formerly inline in `buildArgs` above (see the comment there) — moved to the declarative
     // shape every def now uses to receive `RuntimeBuildOptions.systemPromptOverlay`. Same flag,
     // same probe gate (`capabilityFlags['--append-system-prompt']` above), same "append, never

package/dist/defs/cline.d.ts

@@ -0,0 +1,13 @@
+export declare const clineAgentDef: {
+    id: string;
+    name: string;
+    bin: string;
+    versionArgs: string[];
+    fetchModels: (resolvedBin: string, env: import("../types.js").RuntimeEnv) => Promise<import("../types.js").RuntimeModelOption[]>;
+    fallbackModels: import("../types.js").RuntimeModelOption[];
+    buildArgs: () => string[];
+    streamFormat: string;
+    externalMcpInjection: "acp-merge";
+    imageDelivery: "native";
+};
+//# sourceMappingURL=cline.d.ts.map

package/dist/defs/cline.js

@@ -0,0 +1,32 @@
+/**
+ * @module defs/cline
+ *
+ * Cline CLI (`cline`, npm `cline`). Runs over ACP: `cline --acp` is both the launch command the
+ * official ACP registry lists (<https://github.com/agentclientprotocol/registry>, `cline/agent.json`)
+ * and what an installed `cline` 3.0.60 answered live — `initialize` returned
+ * `promptCapabilities.image: true` and three `authMethods`, and `session/new` on a machine with no
+ * sign-in failed with "Authentication required: Call authenticate before starting a session",
+ * which `auth.ts`'s generic classifier already reads as a missing sign-in (fix: `cline auth`).
+ */
+import { detectAcpModels, DEFAULT_MODEL_OPTION } from './shared.js';
+export const clineAgentDef = {
+    id: 'cline',
+    name: 'Cline',
+    bin: 'cline',
+    versionArgs: ['--version'],
+    fetchModels: async (resolvedBin, env) => detectAcpModels({
+        bin: resolvedBin,
+        args: ['--acp'],
+        env,
+        timeoutMs: 15_000,
+        defaultModelOption: DEFAULT_MODEL_OPTION,
+    }),
+    fallbackModels: [DEFAULT_MODEL_OPTION],
+    buildArgs: () => ['--acp'],
+    streamFormat: 'acp-json-rpc',
+    externalMcpInjection: 'acp-merge',
+    // ACP's `resource_link` prompt blocks carry images natively for every
+    // `acp-json-rpc` def — see `types.ts#RuntimeAgentDef.imageDelivery`'s doc.
+    imageDelivery: 'native',
+};
+//# sourceMappingURL=cline.js.map

package/dist/defs/crush.d.ts

@@ -0,0 +1,11 @@
+export declare const crushAgentDef: {
+    id: string;
+    name: string;
+    bin: string;
+    versionArgs: string[];
+    fallbackModels: import("../types.js").RuntimeModelOption[];
+    buildArgs: (_prompt: string, _imagePaths: string[], _extra: string[] | undefined, options?: import("../types.js").RuntimeBuildOptions | undefined) => string[];
+    promptViaStdin: true;
+    streamFormat: string;
+};
+//# sourceMappingURL=crush.d.ts.map

package/dist/defs/crush.js

@@ -0,0 +1,37 @@
+/**
+ * @module defs/crush
+ *
+ * Charm's Crush (`crush`). Checked against upstream source (`internal/cmd/run.go` / `root.go`):
+ * `crush run [prompt...]` runs one prompt non-interactively and exits; with no prompt args, piped
+ * stdin becomes the whole prompt ("no prompt provided" only when both are empty). The answer is
+ * plain text on stdout, the spinner goes to stderr and `--quiet` hides it. `--yolo` (root flag)
+ * skips permission requests; `--model` takes `model` or `provider/model`.
+ *
+ * No `externalMcpInjection`: Crush reads MCP servers from its `crush.json` config, with no
+ * per-run flag to point it elsewhere.
+ */
+import { DEFAULT_MODEL_OPTION } from './shared.js';
+export const crushAgentDef = {
+    id: 'crush',
+    name: 'Crush',
+    bin: 'crush',
+    versionArgs: ['--version'],
+    // Models come from the providers the user configured in Crush; there is no stable default
+    // list to ship, so the picker offers the CLI default and accepts any typed id.
+    fallbackModels: [DEFAULT_MODEL_OPTION],
+    buildArgs: (_prompt, _imagePaths, _extra, options = {}) => {
+        const args = ['run', '--quiet'];
+        // See `RuntimeBuildOptions.permissionMode`'s doc: bypass is the default (unchanged
+        // behavior) unless a caller explicitly opts into a restricted run.
+        if (options.permissionMode !== 'restricted') {
+            args.push('--yolo');
+        }
+        if (options.model && options.model !== 'default') {
+            args.push('--model', options.model);
+        }
+        return args;
+    },
+    promptViaStdin: true,
+    streamFormat: 'plain',
+};
+//# sourceMappingURL=crush.js.map

package/dist/defs/droid.d.ts

@@ -0,0 +1,11 @@
+export declare const droidAgentDef: {
+    id: string;
+    name: string;
+    bin: string;
+    versionArgs: string[];
+    fallbackModels: import("../types.js").RuntimeModelOption[];
+    buildArgs: (_prompt: string, _imagePaths: string[], _extra: string[] | undefined, options?: import("../types.js").RuntimeBuildOptions | undefined) => string[];
+    promptViaStdin: true;
+    streamFormat: string;
+};
+//# sourceMappingURL=droid.d.ts.map

package/dist/defs/droid.js

@@ -0,0 +1,38 @@
+/**
+ * @module defs/droid
+ *
+ * Factory's Droid CLI (`droid`). Uses the documented headless mode, `droid exec`
+ * (<https://docs.factory.ai/reference/cli-reference>, <https://docs.factory.ai/droid-exec/overview>):
+ * the prompt can be piped on stdin (`cat file | droid exec`), `--output-format text` prints the
+ * final answer, and `-m/--model` picks the model. `droid exec` is read-only unless given an
+ * autonomy level; `--skip-permissions-unsafe` lifts every permission check (it cannot be combined
+ * with `--auto`). Auth is `FACTORY_API_KEY` or a prior `droid` login.
+ *
+ * Not ACP: the ACP registry launches Droid with `droid exec --output-format acp-daemon`, but that
+ * value is not in the CLI reference, newer builds were reported to switch to `acp`, and the daemon
+ * variant was reported to fail with stdio MCP servers. The documented text mode is the stable one.
+ * No `externalMcpInjection` for the same reason.
+ */
+import { DEFAULT_MODEL_OPTION } from './shared.js';
+export const droidAgentDef = {
+    id: 'droid',
+    name: 'Factory Droid',
+    bin: 'droid',
+    versionArgs: ['--version'],
+    fallbackModels: [DEFAULT_MODEL_OPTION],
+    buildArgs: (_prompt, _imagePaths, _extra, options = {}) => {
+        const args = ['exec', '--output-format', 'text'];
+        // See `RuntimeBuildOptions.permissionMode`'s doc: bypass is the default (unchanged
+        // behavior); a restricted run keeps `droid exec`'s own read-only default.
+        if (options.permissionMode !== 'restricted') {
+            args.push('--skip-permissions-unsafe');
+        }
+        if (options.model && options.model !== 'default') {
+            args.push('--model', options.model);
+        }
+        return args;
+    },
+    promptViaStdin: true,
+    streamFormat: 'plain',
+};
+//# sourceMappingURL=droid.js.map

package/dist/defs/gemini.d.ts

@@ -0,0 +1,17 @@
+export declare const geminiAgentDef: {
+    id: string;
+    name: string;
+    bin: string;
+    versionArgs: string[];
+    versionProbeTimeoutMs: number;
+    helpArgs: string[];
+    capabilityFlags: {
+        "--skip-trust": string;
+    };
+    fallbackModels: import("../types.js").RuntimeModelOption[];
+    buildArgs: (_prompt: string, _imagePaths: string[], extraAllowedDirs?: string[] | undefined, options?: import("../types.js").RuntimeBuildOptions | undefined) => string[];
+    promptViaStdin: true;
+    streamFormat: string;
+    eventParser: string;
+};
+//# sourceMappingURL=gemini.d.ts.map

package/dist/defs/gemini.js

@@ -0,0 +1,81 @@
+/**
+ * @module defs/gemini
+ *
+ * Google's Gemini CLI (`gemini`, npm `@google/gemini-cli`). Checked against an installed
+ * `gemini` 0.58.0 (`gemini --help` and the bundled headless code path) and the upstream headless
+ * docs (<https://geminicli.com/docs/cli/headless>):
+ *
+ *   - Headless mode starts whenever stdin is not a TTY; the whole piped stdin becomes the prompt
+ *     (`-p` is only needed to pass the prompt in argv, and would be "appended to input on stdin").
+ *     So the prompt goes over stdin, like the Qwen Code fork, which avoids Windows `spawn
+ *     ENAMETOOLONG` on large composed prompts.
+ *   - `--output-format stream-json` emits the JSONL `init` / `message` / `tool_use` /
+ *     `tool_result` / `error` / `result` events that `json-event-stream.ts`'s `gemini` parser
+ *     already reads.
+ *   - `--approval-mode yolo` auto-approves every tool (the `--yolo` alias does the same).
+ *   - Since folder trust landed, a headless run in an untrusted directory exits with "Gemini CLI
+ *     is not running in a trusted directory. To proceed, either use `--skip-trust`, …". The host
+ *     already chose the run's cwd, so the def trusts it for this session only. Older builds
+ *     reject unknown flags, so `--skip-trust` is gated on the `--help` capability probe.
+ *   - `--include-directories` (repeatable) widens the workspace to dirs outside the cwd.
+ *
+ * Auth: since 2026-06-18 Google no longer serves Gemini CLI's "Login with Google" for free /
+ * Google AI Pro / Ultra individual accounts (the run dies with `IneligibleTierError: This client
+ * is no longer supported for Gemini Code Assist for individuals`). A Gemini API key, Vertex AI,
+ * or a Gemini Code Assist license still works. There is no side-effect-free auth-status
+ * subcommand, so no `authProbe`; `auth.ts#classifyAgentAuthFailure` turns the failure text into
+ * setup guidance instead.
+ */
+import { DEFAULT_MODEL_OPTION } from './shared.js';
+import { agentCapabilities } from '../capabilities.js';
+const SKIP_TRUST_FLAG = '--skip-trust';
+export const geminiAgentDef = {
+    id: 'gemini',
+    name: 'Gemini CLI',
+    bin: 'gemini',
+    versionArgs: ['--version'],
+    // A cold `gemini --version` took 4.7 s on the dev machine (warm ~2 s), past the 3 s default.
+    versionProbeTimeoutMs: 10_000,
+    helpArgs: ['--help'],
+    capabilityFlags: {
+        [SKIP_TRUST_FLAG]: 'skipTrust',
+    },
+    // No `models` subcommand. `auto` and the concrete ids below are the ones the installed
+    // 0.58.0 bundle and the upstream model docs name; any other id can still be typed in.
+    fallbackModels: [
+        DEFAULT_MODEL_OPTION,
+        { id: 'auto', label: 'auto' },
+        { id: 'gemini-3.1-pro-preview', label: 'gemini-3.1-pro-preview' },
+        { id: 'gemini-3.5-flash', label: 'gemini-3.5-flash' },
+        { id: 'gemini-3-pro-preview', label: 'gemini-3-pro-preview' },
+        { id: 'gemini-3-flash-preview', label: 'gemini-3-flash-preview' },
+        { id: 'gemini-2.5-pro', label: 'gemini-2.5-pro' },
+        { id: 'gemini-2.5-flash', label: 'gemini-2.5-flash' },
+    ],
+    buildArgs: (_prompt, _imagePaths, extraAllowedDirs = [], options = {}) => {
+        const args = ['--output-format', 'stream-json'];
+        if (agentCapabilities.get('gemini')?.skipTrust) {
+            args.push(SKIP_TRUST_FLAG);
+        }
+        // See `RuntimeBuildOptions.permissionMode`'s doc: bypass is the default (unchanged
+        // behavior) unless a caller explicitly opts into a restricted run.
+        if (options.permissionMode !== 'restricted') {
+            args.push('--approval-mode', 'yolo');
+        }
+        if (options.model && options.model !== 'default') {
+            args.push('--model', options.model);
+        }
+        const dirs = (extraAllowedDirs || []).filter((d) => typeof d === 'string' && d.length > 0);
+        for (const d of dirs)
+            args.push('--include-directories', d);
+        return args;
+    },
+    promptViaStdin: true,
+    streamFormat: 'json-event-stream',
+    eventParser: 'gemini',
+    // No `externalMcpInjection` yet: Gemini CLI reads `mcpServers` from `settings.json` (user,
+    // project `.gemini/settings.json`, or a system file named by
+    // `GEMINI_CLI_SYSTEM_SETTINGS_PATH`), with no per-run `--mcp-config` flag. A run-scoped
+    // system-settings file is the likely strategy, but it is not wired or verified live.
+};
+//# sourceMappingURL=gemini.js.map

package/dist/defs/goose.d.ts

@@ -0,0 +1,13 @@
+export declare const gooseAgentDef: {
+    id: string;
+    name: string;
+    bin: string;
+    versionArgs: string[];
+    fetchModels: (resolvedBin: string, env: import("../types.js").RuntimeEnv) => Promise<import("../types.js").RuntimeModelOption[]>;
+    fallbackModels: import("../types.js").RuntimeModelOption[];
+    buildArgs: () => string[];
+    streamFormat: string;
+    externalMcpInjection: "acp-merge";
+    imageDelivery: "native";
+};
+//# sourceMappingURL=goose.d.ts.map

package/dist/defs/goose.js

@@ -0,0 +1,33 @@
+/**
+ * @module defs/goose
+ *
+ * Block's goose (`goose`). Runs over ACP: `goose acp` is the launch command the official ACP
+ * registry lists (<https://github.com/agentclientprotocol/registry>, `goose/agent.json`). The
+ * provider and model come from goose's own config, so `goose configure` has to have been run once.
+ *
+ * Name clash: `pressly/goose` (a Go database-migration tool) also installs a `goose` binary. On a
+ * machine that has only that one, detection will list goose as installed and the first run will
+ * fail on the unknown `acp` command.
+ */
+import { detectAcpModels, DEFAULT_MODEL_OPTION } from './shared.js';
+export const gooseAgentDef = {
+    id: 'goose',
+    name: 'goose',
+    bin: 'goose',
+    versionArgs: ['--version'],
+    fetchModels: async (resolvedBin, env) => detectAcpModels({
+        bin: resolvedBin,
+        args: ['acp'],
+        env,
+        timeoutMs: 15_000,
+        defaultModelOption: DEFAULT_MODEL_OPTION,
+    }),
+    fallbackModels: [DEFAULT_MODEL_OPTION],
+    buildArgs: () => ['acp'],
+    streamFormat: 'acp-json-rpc',
+    externalMcpInjection: 'acp-merge',
+    // ACP's `resource_link` prompt blocks carry images natively for every
+    // `acp-json-rpc` def — see `types.ts#RuntimeAgentDef.imageDelivery`'s doc.
+    imageDelivery: 'native',
+};
+//# sourceMappingURL=goose.js.map

package/dist/defs/index.d.ts

@@ -10,13 +10,19 @@ export * from './aider.js';
 export * from './amp.js';
 export * from './amr.js';
 export * from './antigravity.js';
+export * from './auggie.js';
 export * from './claude.js';
+export * from './cline.js';
 export * from './codebuddy.js';
 export * from './codex.js';
 export * from './copilot.js';
+export * from './crush.js';
 export * from './cursor-agent.js';
+export * from './droid.js';
+export * from './gemini.js';
 export * from './deepseek.js';
 export * from './devin.js';
+export * from './goose.js';
 export * from './grok-build.js';
 export * from './hermes.js';
 export * from './kilo.js';

package/dist/defs/index.js

@@ -10,13 +10,19 @@ export * from './aider.js';
 export * from './amp.js';
 export * from './amr.js';
 export * from './antigravity.js';
+export * from './auggie.js';
 export * from './claude.js';
+export * from './cline.js';
 export * from './codebuddy.js';
 export * from './codex.js';
 export * from './copilot.js';
+export * from './crush.js';
 export * from './cursor-agent.js';
+export * from './droid.js';
+export * from './gemini.js';
 export * from './deepseek.js';
 export * from './devin.js';
+export * from './goose.js';
 export * from './grok-build.js';
 export * from './hermes.js';
 export * from './kilo.js';

package/dist/detection.d.ts

@@ -4,6 +4,26 @@ type FetchedRuntimeModels = {
     models: RuntimeModelOption[];
     source: RuntimeModelSource;
 };
+/**
+ * Makes sure `agentCapabilities` holds this def's `--help`-probed flags before its `buildArgs` runs.
+ *
+ * Why this exists: `agentCapabilities` used to be filled ONLY by {@link detectAgents}. A host whose
+ * run process never calls `detectAgents` (it lists agents with its own lighter probe, or not at
+ * all) left the map empty for every run, so every probe-gated flag stayed off for good — for
+ * `claude` that meant no `--include-partial-messages` (no streamed text) and no `--effort`, even on
+ * a CLI that supports both. The run path calls this with the exact launch path and env it is about
+ * to spawn, so the gate reflects the binary that actually runs.
+ *
+ * A no-op when the def declares no probe or the map already has an entry (a `detectAgents` result
+ * wins). Probes once per def id + launch path for the life of the process. A failed probe records
+ * nothing, which keeps the safe baseline (no optional flags), and is not retried on every run.
+ *
+ * @param def - The def about to be spawned.
+ * @param launchPath - The resolved executable the run will spawn.
+ * @param env - The env the run will spawn with.
+ * @complexity O(1) after the first call per def + path; the first call costs one `--help` spawn (5 s cap).
+ */
+export declare function ensureAgentCapabilities(def: RuntimeAgentDef, launchPath: string, env: NodeJS.ProcessEnv): Promise<void>;
 /** Result of {@link probeAgentModels}: the models to surface and where they came from. */
 export type ProbedAgentModels = FetchedRuntimeModels;
 /**

package/dist/detection.js

@@ -140,12 +140,7 @@ async function probeCapabilities(def, launchPath, env) {
     if (!def.helpArgs || !def.capabilityFlags)
         return null;
     try {
-        const { stdout } = await execAgentFile(launchPath, def.helpArgs, { env, timeout: 5000, maxBuffer: 4 * 1024 * 1024 });
-        const caps = {};
-        for (const [flag, key] of Object.entries(def.capabilityFlags)) {
-            caps[key] = String(stdout).includes(flag);
-        }
-        return caps;
+        return await readCapabilities(def.helpArgs, def.capabilityFlags, launchPath, env);
     }
     catch {
         // If --help fails, leave caps empty so buildArgs falls back to the
@@ -153,6 +148,51 @@ async function probeCapabilities(def, launchPath, env) {
         return {};
     }
 }
+/** Runs the def's `--help` probe and maps each advertised flag to its capability key; throws on a failed probe. */
+async function readCapabilities(helpArgs, capabilityFlags, launchPath, env) {
+    const { stdout } = await execAgentFile(launchPath, [...helpArgs], { env, timeout: 5000, maxBuffer: 4 * 1024 * 1024 });
+    const caps = {};
+    for (const [flag, key] of Object.entries(capabilityFlags)) {
+        caps[key] = String(stdout).includes(flag);
+    }
+    return caps;
+}
+/** One in-flight or settled `--help` probe per def id + launch path, so a run never re-spawns it. */
+const capabilityProbes = new Map();
+/**
+ * Makes sure `agentCapabilities` holds this def's `--help`-probed flags before its `buildArgs` runs.
+ *
+ * Why this exists: `agentCapabilities` used to be filled ONLY by {@link detectAgents}. A host whose
+ * run process never calls `detectAgents` (it lists agents with its own lighter probe, or not at
+ * all) left the map empty for every run, so every probe-gated flag stayed off for good — for
+ * `claude` that meant no `--include-partial-messages` (no streamed text) and no `--effort`, even on
+ * a CLI that supports both. The run path calls this with the exact launch path and env it is about
+ * to spawn, so the gate reflects the binary that actually runs.
+ *
+ * A no-op when the def declares no probe or the map already has an entry (a `detectAgents` result
+ * wins). Probes once per def id + launch path for the life of the process. A failed probe records
+ * nothing, which keeps the safe baseline (no optional flags), and is not retried on every run.
+ *
+ * @param def - The def about to be spawned.
+ * @param launchPath - The resolved executable the run will spawn.
+ * @param env - The env the run will spawn with.
+ * @complexity O(1) after the first call per def + path; the first call costs one `--help` spawn (5 s cap).
+ */
+export function ensureAgentCapabilities(def, launchPath, env) {
+    const { helpArgs, capabilityFlags } = def;
+    if (!helpArgs || !capabilityFlags || agentCapabilities.has(def.id))
+        return Promise.resolve();
+    const key = `${def.id}\u0000${launchPath}`;
+    const existing = capabilityProbes.get(key);
+    if (existing)
+        return existing;
+    const probe = readCapabilities(helpArgs, capabilityFlags, launchPath, env).then((caps) => {
+        if (!agentCapabilities.has(def.id))
+            agentCapabilities.set(def.id, caps);
+    }, () => undefined);
+    capabilityProbes.set(key, probe);
+    return probe;
+}
 /**
  * The effort-level override a live model catalog earns, if any.
  *

package/dist/executables.js

@@ -28,13 +28,19 @@ import { expandHomePath } from './paths.js';
 const AGENT_BIN_ENV_KEYS = new Map([
     ['amr', 'VELA_BIN'],
     ['aider', 'AIDER_BIN'],
+    ['auggie', 'AUGGIE_BIN'],
     ['claude', 'CLAUDE_BIN'],
+    ['cline', 'CLINE_BIN'],
     ['codebuddy', 'CODEBUDDY_BIN'],
     ['codex', 'CODEX_BIN'],
     ['copilot', 'COPILOT_BIN'],
+    ['crush', 'CRUSH_BIN'],
     ['cursor-agent', 'CURSOR_AGENT_BIN'],
     ['deepseek', 'DEEPSEEK_BIN'],
     ['devin', 'DEVIN_BIN'],
+    ['droid', 'DROID_BIN'],
+    ['gemini', 'GEMINI_BIN'],
+    ['goose', 'GOOSE_BIN'],
     ['hermes', 'HERMES_BIN'],
     ['kimi', 'KIMI_BIN'],
     ['kiro', 'KIRO_BIN'],

package/dist/metadata.js

@@ -35,6 +35,10 @@ export const DEFAULT_AGENT_INSTALL_LINKS = {
         installUrl: 'https://cursor.com/docs/cli/overview',
         docsUrl: 'https://docs.cursor.com/en/cli/overview',
     },
+    gemini: {
+        installUrl: 'https://github.com/google-gemini/gemini-cli',
+        docsUrl: 'https://geminicli.com/docs/',
+    },
     qwen: {
         installUrl: 'https://github.com/QwenLM/qwen-code',
         docsUrl: 'https://qwenlm.github.io/qwen-code-docs/en/index',
@@ -74,6 +78,26 @@ export const DEFAULT_AGENT_INSTALL_LINKS = {
         installUrl: 'https://www.codebuddy.cn',
         docsUrl: 'https://www.codebuddy.cn/docs/workbuddy/Overview',
     },
+    cline: {
+        installUrl: 'https://cline.bot/cli',
+        docsUrl: 'https://docs.cline.bot/cline-cli/overview',
+    },
+    goose: {
+        installUrl: 'https://github.com/block/goose',
+        docsUrl: 'https://block.github.io/goose/',
+    },
+    auggie: {
+        installUrl: 'https://github.com/augmentcode/auggie',
+        docsUrl: 'https://docs.augmentcode.com/cli/overview',
+    },
+    crush: {
+        installUrl: 'https://github.com/charmbracelet/crush',
+        docsUrl: 'https://github.com/charmbracelet/crush',
+    },
+    droid: {
+        installUrl: 'https://factory.ai/product/cli',
+        docsUrl: 'https://docs.factory.ai/droid-exec/overview',
+    },
 };
 function sanitizeHttpsUrl(value) {
     if (!value)

package/dist/registry.d.ts

@@ -7,8 +7,8 @@ export declare function getAgentDef(id: string): RuntimeAgentDef | null;
  * tools) into a session run by this
  * def, per its own `externalMcpInjection` declaration (`types.ts`'s own doc names the six wired
  * strategies and the defs that leave the field `undefined` because the CLI has no mechanism to
- * receive one — `aider`, `amp`, `copilot`, `cursor-agent`, `deepseek`, `grok-build`, `pi`,
- * `qoder`, and `qwen` today, each documenting why in its own def file).
+ * receive one — `aider`, `amp`, `copilot`, `crush`, `cursor-agent`, `deepseek`, `droid`,
+ * `gemini`, `grok-build`, `pi`, `qoder`, and `qwen` today, each documenting why in its own def file).
  *
  * This is the single seam a tool-availability UI (e.g. the chat runtime picker's "No tools" badge)
  * should read instead of hardcoding a runtime-id list: that list goes stale the moment a def gains

package/dist/registry.js

@@ -1,7 +1,7 @@
 /**
  * @module registry
  *
- * The static `BASE_AGENT_DEFS` catalog (the 24 built-in CLI adapters), a
+ * The static `BASE_AGENT_DEFS` catalog (the built-in CLI adapters), a
  * dup-id guard, and `getAgentDef(id)` lookup.
  *
  * Ported from OD's `apps/daemon/src/runtimes/registry.ts`. Per the
@@ -17,7 +17,7 @@
  * can reintroduce a de-branded, sandbox-free local-profile loader as an
  * injected port if a consumer needs it. See `source-map.md`.
  */
-import { aiderAgentDef, ampAgentDef, amrAgentDef, antigravityAgentDef, claudeAgentDef, codebuddyAgentDef, codexAgentDef, copilotAgentDef, cursorAgentDef, deepseekAgentDef, devinAgentDef, grokBuildAgentDef, hermesAgentDef, kiloAgentDef, kimiAgentDef, kiroAgentDef, mimoAgentDef, opencodeAgentDef, piAgentDef, qoderAgentDef, qwenAgentDef, reasonixAgentDef, traeCliAgentDef, vibeAgentDef, } from './defs/index.js';
+import { aiderAgentDef, ampAgentDef, amrAgentDef, antigravityAgentDef, auggieAgentDef, claudeAgentDef, clineAgentDef, codebuddyAgentDef, codexAgentDef, copilotAgentDef, crushAgentDef, cursorAgentDef, deepseekAgentDef, devinAgentDef, droidAgentDef, geminiAgentDef, gooseAgentDef, grokBuildAgentDef, hermesAgentDef, kiloAgentDef, kimiAgentDef, kiroAgentDef, mimoAgentDef, opencodeAgentDef, piAgentDef, qoderAgentDef, qwenAgentDef, reasonixAgentDef, traeCliAgentDef, vibeAgentDef, } from './defs/index.js';
 export const BASE_AGENT_DEFS = [
     amrAgentDef,
     claudeAgentDef,
@@ -30,6 +30,7 @@ export const BASE_AGENT_DEFS = [
     kimiAgentDef,
     cursorAgentDef,
     qwenAgentDef,
+    geminiAgentDef,
     qoderAgentDef,
     copilotAgentDef,
     ampAgentDef,
@@ -43,6 +44,11 @@ export const BASE_AGENT_DEFS = [
     reasonixAgentDef,
     codebuddyAgentDef,
     mimoAgentDef,
+    clineAgentDef,
+    gooseAgentDef,
+    auggieAgentDef,
+    crushAgentDef,
+    droidAgentDef,
 ];
 export const AGENT_DEFS = [...BASE_AGENT_DEFS];
 const ids = new Set();
@@ -60,8 +66,8 @@ export function getAgentDef(id) {
  * tools) into a session run by this
  * def, per its own `externalMcpInjection` declaration (`types.ts`'s own doc names the six wired
  * strategies and the defs that leave the field `undefined` because the CLI has no mechanism to
- * receive one — `aider`, `amp`, `copilot`, `cursor-agent`, `deepseek`, `grok-build`, `pi`,
- * `qoder`, and `qwen` today, each documenting why in its own def file).
+ * receive one — `aider`, `amp`, `copilot`, `crush`, `cursor-agent`, `deepseek`, `droid`,
+ * `gemini`, `grok-build`, `pi`, `qoder`, and `qwen` today, each documenting why in its own def file).
  *
  * This is the single seam a tool-availability UI (e.g. the chat runtime picker's "No tools" badge)
  * should read instead of hardcoding a runtime-id list: that list goes stale the moment a def gains

package/dist/types.d.ts

@@ -95,6 +95,21 @@ export type RuntimeBuildOptions = {
      * `undefined`/empty means no restriction, same as today.
      */
     allowedTools?: readonly string[];
+    /**
+     * Which of the CLI's own settings layers to load — today `claude`'s `--setting-sources`
+     * (`user`, `project`, `local`). An EMPTY list loads none: no settings-file hooks, no plugins the
+     * operator enabled for themselves, no personal model/effort defaults. For a host that embeds the
+     * CLI as a product assistant, so the operator's personal setup (e.g. SessionStart hooks that
+     * inject their own instructions) never reaches the product's runs. Unlike staging a separate
+     * `CLAUDE_CONFIG_DIR`, this keeps the CLI's Keychain login. `undefined` = the CLI's default (all).
+     */
+    settingSources?: readonly string[];
+    /**
+     * Extra settings for this run — today `claude`'s `--settings <file-or-json>`, which the CLI applies
+     * on top of (and independently of) {@link settingSources}. Lets a host that loads no settings layers
+     * still hand the run the few it wants, e.g. one PreToolUse hook. `undefined`/empty = no flag.
+     */
+    settings?: string;
 };
 export type RuntimeContext = {
     cwd?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/agent-runtime",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "description": "Coding-agent runtime adapters: runtime registry, detection, launch, stream parsers, and the ACP/pi-rpc subprocess transport.",
   "license": "Apache-2.0",
   "repository": {
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "@jini-ai/platform": "0.3.0",
-    "@jini-ai/protocol": "0.3.0"
+    "@jini-ai/protocol": "0.3.1"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^2.1.9"