@tangle-network/agent-interface 0.16.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 {

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);
 }
 /**
@@ -164,8 +185,8 @@ export function reasoningEffortsFor(harness, model) {
  *
  *   - 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` and `factory-droids`/`hermes`/`nanoclaw` (no thinking flag is plumbed to
- *     the underlying CLI).
+ *   - 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.
@@ -180,6 +201,7 @@ const harnessIgnoresEffort = new Set([
     "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) {

package/package.json

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