@tangle-network/agent-interface 0.15.0 → 0.17.0

package/dist/harness-capabilities.d.ts

@@ -43,7 +43,8 @@ export declare function snapModelToHarness(harness: HarnessType, modelId: string
  * `opencode` for everything else.
  */
 export declare function snapHarnessToModel(harness: HarnessType, modelId: string): HarnessType;
-/** The reasoning efforts a harness can express, independent of model — `none` up to its ceiling. */
+/** The reasoning efforts a harness can express, independent of model — its explicit override set, or
+ *  `none` up to its ceiling (default `ultracode` for router/model-driven harnesses). */
 export declare function harnessReasoningEfforts(harness: HarnessType): readonly ReasoningEffort[];
 /** What the caller knows about a model's own reasoning capability (from a model catalog). */
 export interface ModelReasoningCapability {
@@ -58,3 +59,9 @@ export interface ModelReasoningCapability {
  * lower ceiling caps the list there. Pass `model` from your catalog; omit it for the harness-only set.
  */
 export declare function reasoningEffortsFor(harness: HarnessType, model?: ModelReasoningCapability | null): readonly ReasoningEffort[];
+/** Whether the harness's runner honors a per-turn MODEL override (vs. picking the model itself). */
+export declare function harnessHonorsModel(harness: HarnessType): boolean;
+/** Whether the harness's runner honors a reasoning-EFFORT override (vs. dropping it). */
+export declare function harnessHonorsEffort(harness: HarnessType): boolean;
+/** Whether the harness honors BOTH chat selectors — i.e. the model and effort pickers are live. */
+export declare function harnessHonorsSelectors(harness: HarnessType): boolean;

package/dist/harness-capabilities.js

@@ -122,22 +122,43 @@ export function snapHarnessToModel(harness, modelId) {
 }
 // ── Reasoning-effort support ──────────────────────────────────────────────────
 /**
- * The highest reasoning effort a harness's runtime can express (its native clamp ceiling). Grounded
- * in cli-bridge: codex's `model_reasoning_effort` caps at `high` (xhigh/ultracode clamp down); kimi's
- * `--thinking` is binary, so `high` is its "on"; claude-code carries the full range; `cli-base` has
- * no agent and thus no thinking; `nanoclaw`'s runner sends no thinking flag, so it expresses only
- * `none`. Router/model-driven harnesses default to the full range.
+ * The explicit reasoning-effort set a harness's runtime accepts when it ISN'T a plain `none…ceiling`
+ * slice — grounded in the cli-bridge adapters (NOT the canonical ladder):
+ *   - codex: `model_reasoning_effort` accepts `minimal|low|medium|high` (xhigh/ultracode clamp down);
+ *     it has no real `none` (the flag is just omitted), so `none` is dropped — `auto` covers "default".
+ *   - claude-code: `--effort` accepts `low|medium|high|xhigh|max`. `ultracode` is the ladder's stand-in
+ *     for claude's `max` (clamped at runtime); `minimal`→`low` and `none`/`auto`→no flag, so both are
+ *     dropped as redundant.
+ *   - pi / openclaw: `--thinking` accepts `minimal…xhigh` (max/ultracode clamp to `xhigh`; no `none`).
+ *   - kimi-code: `--thinking` is BINARY (off/on) — `minimal` is the only value that emits
+ *     `--no-thinking`, `high` is "thinking on". So two levels, not five.
+ */
+const harnessReasoningEffortsOverride = {
+    codex: ["minimal", "low", "medium", "high"],
+    "claude-code": ["low", "medium", "high", "xhigh", "ultracode"],
+    pi: ["minimal", "low", "medium", "high", "xhigh"],
+    openclaw: ["minimal", "low", "medium", "high", "xhigh"],
+    "kimi-code": ["minimal", "high"],
+};
+/**
+ * The ceiling for harnesses whose set IS a plain `none…ceiling` slice. Only the no-thinking runners
+ * need an entry (`cli-base` has no agent; `nanoclaw` sends no thinking flag). Harnesses with a
+ * provider-clamped or non-contiguous set live in {@link harnessReasoningEffortsOverride}; router /
+ * model-driven harnesses (opencode, gemini, …) have no entry → default to the full ladder, narrowed
+ * by the model's own capability.
  */
 const harnessReasoningCeiling = {
     "cli-base": "none",
-    codex: "high",
-    "kimi-code": "high",
-    "claude-code": "ultracode",
     nanoclaw: "none",
 };
-/** The reasoning efforts a harness can express, independent of model — `none` up to its ceiling. */
+/** The reasoning efforts a harness can express, independent of model — its explicit override set, or
+ *  `none` up to its ceiling (default `ultracode` for router/model-driven harnesses). */
 export function harnessReasoningEfforts(harness) {
-    const ceiling = harnessReasoningCeiling[canonicalizeHarness(harness)] ?? "ultracode";
+    const canonical = canonicalizeHarness(harness);
+    const override = harnessReasoningEffortsOverride[canonical];
+    if (override)
+        return override;
+    const ceiling = harnessReasoningCeiling[canonical] ?? "ultracode";
     return reasoningLadder.slice(0, reasoningLadder.indexOf(ceiling) + 1);
 }
 /**
@@ -156,3 +177,41 @@ export function reasoningEffortsFor(harness, model) {
     }
     return efforts;
 }
+// ── Per-turn selector support (does the harness honor the chat pickers?) ──────
+/**
+ * Harnesses whose runner DROPS a per-turn selector — grounded in the cli-bridge adapter audit, NOT a
+ * guess. Most harnesses honor both selectors, so only the exceptions are listed; a harness absent from
+ * a set honors that selector. Keyed by the BASE runner (aliases canonicalized).
+ *
+ *   - model dropped:  `amp` (own agent picks the model), `openclaw` (dispatcher routes by its own
+ *     config), `nanoclaw` (socket-bridge runner is config/env-driven).
+ *   - effort dropped: `amp`, `factory-droids`, `hermes`, `nanoclaw`, and `acp` (no thinking flag is
+ *     plumbed to the underlying CLI — the runner reads no `reasoningEffort`).
+ *
+ * This is distinct from {@link reasoningEffortsFor} (which levels a harness can EXPRESS): a picker uses
+ * these to trim or mark harnesses up front, so a user's model/effort choice is never silently ignored.
+ */
+const harnessIgnoresModel = new Set([
+    "amp",
+    "openclaw",
+    "nanoclaw",
+]);
+const harnessIgnoresEffort = new Set([
+    "amp",
+    "factory-droids",
+    "hermes",
+    "nanoclaw",
+    "acp",
+]);
+/** Whether the harness's runner honors a per-turn MODEL override (vs. picking the model itself). */
+export function harnessHonorsModel(harness) {
+    return !harnessIgnoresModel.has(canonicalizeHarness(harness));
+}
+/** Whether the harness's runner honors a reasoning-EFFORT override (vs. dropping it). */
+export function harnessHonorsEffort(harness) {
+    return !harnessIgnoresEffort.has(canonicalizeHarness(harness));
+}
+/** Whether the harness honors BOTH chat selectors — i.e. the model and effort pickers are live. */
+export function harnessHonorsSelectors(harness) {
+    return harnessHonorsModel(harness) && harnessHonorsEffort(harness);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-interface",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "type": "module",
   "license": "MIT",
   "main": "./dist/index.js",