@tangle-network/agent-interface 0.16.0 → 0.17.1

package/dist/agent-profile.d.ts

@@ -92,7 +92,8 @@ export interface AgentProfileResources {
  *   - `minimal`  — thinking ON, the lowest budget (distinct from `none`)
  *   - `low` / `medium` / `high` / `xhigh`
  *   - `ultracode` — maximum (claude-code's "ultracode" run mode; codex's `max` reconciles here).
- * A backend without a matching native tier clamps to its nearest (e.g. codex maps `xhigh`/`ultracode` → `high`).
+ * A backend without a matching native tier clamps to its nearest (e.g. codex maps `ultracode` → `xhigh`
+ * on models that support it).
  */
 export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "ultracode";
 /**

package/dist/harness-capabilities.d.ts

@@ -11,9 +11,10 @@ import { type HarnessType } from "./harness.js";
  * cli-bridge backends, the sandbox UI pickers, and the router all read one truth instead of each
  * hand-rolling a divergent copy.
  *
- * Grounded in cli-bridge's real backend clamps (codex caps at `high`, kimi is binary on/off, claude
- * carries the full range, cli-base has no agent) — NOT a guessed matrix. The per-MODEL reasoning
- * capability (does this specific model reason at all) is dynamic catalog data the caller supplies.
+ * Grounded in cli-bridge's real backend clamps (codex is `low..xhigh` for current models, kimi is
+ * binary on/off, claude carries the full range, cli-base has no agent) — NOT a guessed matrix. The
+ * per-MODEL reasoning capability (does this specific model reason at all) is dynamic catalog data the
+ * caller supplies.
  */
 /** low → high. `none` = thinking off; `ultracode` = max (claude-code mode). */
 export declare const reasoningLadder: readonly ReasoningEffort[];
@@ -43,7 +44,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

@@ -10,9 +10,10 @@ import { canonicalizeHarness } from "./harness.js";
  * cli-bridge backends, the sandbox UI pickers, and the router all read one truth instead of each
  * hand-rolling a divergent copy.
  *
- * Grounded in cli-bridge's real backend clamps (codex caps at `high`, kimi is binary on/off, claude
- * carries the full range, cli-base has no agent) — NOT a guessed matrix. The per-MODEL reasoning
- * capability (does this specific model reason at all) is dynamic catalog data the caller supplies.
+ * Grounded in cli-bridge's real backend clamps (codex is `low..xhigh` for current models, kimi is
+ * binary on/off, claude carries the full range, cli-base has no agent) — NOT a guessed matrix. The
+ * per-MODEL reasoning capability (does this specific model reason at all) is dynamic catalog data the
+ * caller supplies.
  */
 /** low → high. `none` = thinking off; `ultracode` = max (claude-code mode). */
 export const reasoningLadder = [
@@ -122,22 +123,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: current models advertise `low|medium|high|xhigh`; `none` is omitted (use `auto`) and
+ *     legacy `minimal` requests clamp up to `low`.
+ *   - 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: ["low", "medium", "high", "xhigh"],
+    "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 +186,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 +202,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.1",
   "type": "module",
   "license": "MIT",
   "main": "./dist/index.js",