@tangle-network/agent-interface 0.7.0 → 0.9.0

package/dist/agent-profile.d.ts

@@ -87,11 +87,14 @@ export interface AgentProfileResources {
 /**
  * Portable reasoning/thinking effort. Backends map it to their native control at materialization:
  * codex `model_reasoning_effort`, kimi `--thinking`/`--no-thinking`, claude thinking budget.
- * Ordered low→high: `none` = no extended thinking; `ultracode` = maximum (claude-code's
- * "ultracode" run mode). A backend without a matching native tier clamps to its nearest
- * (e.g. codex maps `xhigh`/`ultracode` → `high`).
+ * Ordered low→high:
+ *   - `none`     — extended thinking OFF (no reasoning budget at all)
+ *   - `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`).
  */
-export type ReasoningEffort = 'none' | 'low' | 'medium' | 'high' | 'xhigh' | 'ultracode';
+export type ReasoningEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'ultracode';
 /**
  * Model selection hints for backends.
  */

package/dist/harness-capabilities.d.ts

@@ -0,0 +1,46 @@
+import type { ReasoningEffort } from "./agent-profile.js";
+import { type HarnessType } from "./harness.js";
+/**
+ * The unified harness capability layer — the single source of truth for:
+ *   1. harness ↔ model compatibility (which models a harness can run), and
+ *   2. reasoning-effort support (which thinking levels a harness/model expresses).
+ *
+ * Both are facets of the same question — "what can this (harness, model) pair actually do" — and
+ * apply to BOTH harness-backed systems (vendor-locked CLIs like claude-code/codex/kimi) AND
+ * router-backed systems (opencode, cli-base: any model the router serves). Lifted here so the
+ * 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.
+ */
+/** low → high. `none` = thinking off; `ultracode` = max (claude-code mode). */
+export declare const reasoningLadder: readonly ReasoningEffort[];
+/** Provider prefix of a canonical model id (`anthropic/claude-…` → `anthropic`), or null. */
+export declare function modelProvider(modelId: string): string | null;
+/** The providers a harness is locked to, or `null` when it is router-backed (any model). */
+export declare function harnessProviders(harness: HarnessType): readonly string[] | null;
+/**
+ * Whether a harness can run a model. Router-backed harnesses (no provider lock) accept anything;
+ * a model id with no provider prefix (a sentinel like `default`) is treated as compatible too.
+ */
+export declare function harnessSupportsModel(harness: HarnessType, modelId: string): boolean;
+/** The harness to adopt for a model whose provider is vendor-locked (`anthropic` → `claude-code`,
+ *  `openai` → `codex`, `moonshot` → `kimi-code`); `null` when any router-backed harness will do. */
+export declare function preferredHarnessForModel(modelId: string): HarnessType | null;
+/** The reasoning efforts a harness can express, independent of model — `none` up to its ceiling. */
+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 {
+    /** Does the model reason at all? `false` → only `none` is offered, on any harness. */
+    supportsReasoning?: boolean;
+    /** The model's own ceiling, if narrower than the harness's. */
+    maxEffort?: ReasoningEffort;
+}
+/**
+ * The effective reasoning efforts for a (harness, model) pair: the harness clamp, further narrowed by
+ * the model's own capability. A model that doesn't reason collapses to `['none']`; a model with a
+ * 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[];

package/dist/harness-capabilities.js

@@ -0,0 +1,105 @@
+import { canonicalizeHarness } from "./harness.js";
+/**
+ * The unified harness capability layer — the single source of truth for:
+ *   1. harness ↔ model compatibility (which models a harness can run), and
+ *   2. reasoning-effort support (which thinking levels a harness/model expresses).
+ *
+ * Both are facets of the same question — "what can this (harness, model) pair actually do" — and
+ * apply to BOTH harness-backed systems (vendor-locked CLIs like claude-code/codex/kimi) AND
+ * router-backed systems (opencode, cli-base: any model the router serves). Lifted here so the
+ * 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.
+ */
+/** low → high. `none` = thinking off; `ultracode` = max (claude-code mode). */
+export const reasoningLadder = [
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "ultracode",
+];
+// ── Harness ↔ model compatibility ────────────────────────────────────────────
+/**
+ * Provider prefixes a harness is vendor-locked to (canonical-id prefix, e.g. `anthropic`, `openai`).
+ * A harness with no entry is router-backed: it runs any model. Keyed by the BASE runner — aliases
+ * (`claude`/`claudish`/`kimi`) resolve through `canonicalizeHarness` first.
+ */
+const harnessProviderLock = {
+    "claude-code": ["anthropic"],
+    nanoclaw: ["anthropic"],
+    codex: ["openai"],
+    "kimi-code": ["moonshot"],
+};
+/** Provider prefix of a canonical model id (`anthropic/claude-…` → `anthropic`), or null. */
+export function modelProvider(modelId) {
+    const slash = modelId.indexOf("/");
+    return slash > 0 ? modelId.slice(0, slash) : null;
+}
+/** The providers a harness is locked to, or `null` when it is router-backed (any model). */
+export function harnessProviders(harness) {
+    return harnessProviderLock[canonicalizeHarness(harness)] ?? null;
+}
+/**
+ * Whether a harness can run a model. Router-backed harnesses (no provider lock) accept anything;
+ * a model id with no provider prefix (a sentinel like `default`) is treated as compatible too.
+ */
+export function harnessSupportsModel(harness, modelId) {
+    const providers = harnessProviders(harness);
+    if (!providers)
+        return true;
+    const provider = modelProvider(modelId);
+    return provider === null || providers.includes(provider);
+}
+/** The harness to adopt for a model whose provider is vendor-locked (`anthropic` → `claude-code`,
+ *  `openai` → `codex`, `moonshot` → `kimi-code`); `null` when any router-backed harness will do. */
+export function preferredHarnessForModel(modelId) {
+    const provider = modelProvider(modelId);
+    if (!provider)
+        return null;
+    for (const [harness, providers] of Object.entries(harnessProviderLock)) {
+        if (providers?.includes(provider))
+            return harness;
+    }
+    return null;
+}
+// ── 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. Router/model-driven harnesses default to the full range.
+ */
+const harnessReasoningCeiling = {
+    "cli-base": "none",
+    codex: "high",
+    "kimi-code": "high",
+    "claude-code": "ultracode",
+    nanoclaw: "ultracode",
+};
+/** The reasoning efforts a harness can express, independent of model — `none` up to its ceiling. */
+export function harnessReasoningEfforts(harness) {
+    const ceiling = harnessReasoningCeiling[canonicalizeHarness(harness)] ?? "ultracode";
+    return reasoningLadder.slice(0, reasoningLadder.indexOf(ceiling) + 1);
+}
+/**
+ * The effective reasoning efforts for a (harness, model) pair: the harness clamp, further narrowed by
+ * the model's own capability. A model that doesn't reason collapses to `['none']`; a model with a
+ * lower ceiling caps the list there. Pass `model` from your catalog; omit it for the harness-only set.
+ */
+export function reasoningEffortsFor(harness, model) {
+    if (model?.supportsReasoning === false)
+        return ["none"];
+    let efforts = harnessReasoningEfforts(harness);
+    if (model?.maxEffort) {
+        const cap = reasoningLadder.indexOf(model.maxEffort);
+        if (cap >= 0)
+            efforts = efforts.filter((e) => reasoningLadder.indexOf(e) <= cap);
+    }
+    return efforts;
+}

package/dist/index.d.ts

@@ -580,4 +580,5 @@ export interface SdkProviderAdapter {
 }
 export * from "./agent-profile.js";
 export * from "./harness.js";
+export * from "./harness-capabilities.js";
 export * from "./profile-schema.js";

package/dist/index.js

@@ -124,4 +124,5 @@ export function resolveNativeWebTools(tools) {
 }
 export * from "./agent-profile.js";
 export * from "./harness.js";
+export * from "./harness-capabilities.js";
 export * from "./profile-schema.js";

package/dist/profile-schema.d.ts

@@ -118,6 +118,7 @@ export declare const agentProfileModelHintsSchema: z.ZodObject<{
     provider: z.ZodOptional<z.ZodString>;
     reasoningEffort: z.ZodOptional<z.ZodEnum<{
         none: "none";
+        minimal: "minimal";
         low: "low";
         medium: "medium";
         high: "high";
@@ -211,6 +212,7 @@ export declare const agentProfileSchema: z.ZodObject<{
         provider: z.ZodOptional<z.ZodString>;
         reasoningEffort: z.ZodOptional<z.ZodEnum<{
             none: "none";
+            minimal: "minimal";
             low: "low";
             medium: "medium";
             high: "high";

package/dist/profile-schema.js

@@ -37,7 +37,7 @@ export const agentProfileModelHintsSchema = z.object({
     default: z.string().optional(),
     small: z.string().optional(),
     provider: z.string().optional(),
-    reasoningEffort: z.enum(['none', 'low', 'medium', 'high', 'xhigh', 'ultracode']).optional(),
+    reasoningEffort: z.enum(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'ultracode']).optional(),
     metadata: z.record(z.string(), z.unknown()).optional(),
 });
 export const agentProfilePromptSchema = z.object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-interface",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",