@tangle-network/agent-interface 0.8.0 → 0.9.0

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/package.json

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