@jini-ai/agent-runtime 0.3.9 → 0.3.10

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/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/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.9",
+  "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"