@tangle-network/cli-agent-registry 0.0.0-stage → 0.14.0

package/dist/native-session-contracts.d.mts

@@ -0,0 +1,354 @@
+import { o as NativeSessionStore } from "./session-contract-BC75JdnA.mjs";
+
+//#region src/native-session-contracts.d.ts
+/**
+ * The native session projection of the per-harness declarations in harness-contracts/. Each entry is
+ * proven by a conformance receipt (tests/harness/receipts) for
+ * its pinned CLI version, or is listed in HARNESS_CONFORMANCE_PENDING.
+ *
+ * CLI versions are the pins in infra/nix (agent-clis.json and flake.nix),
+ * generated into harness-cli-versions.ts by the bump. The registry test
+ * tests/harness-session-contract.test.ts fails when a pin, a contract or an
+ * adapter's source moves without a new receipt.
+ */
+declare const NATIVE_SESSION_CONTRACTS: {
+  readonly "claude-code": {
+    version: 1;
+    stores: [NativeSessionStore];
+    identity: {
+      kind: "pre-minted";
+      args: string[];
+    };
+    resume: {
+      kind: "args";
+      args: string[];
+    };
+    forbiddenArgs: string[];
+    storeEnv: {
+      CLAUDE_CONFIG_DIR: string;
+    };
+    evidence: {
+      servedModel: "provider-response";
+      usage: "per-response";
+      endingError: "session-record";
+    };
+    cliVersion: "2.1.311";
+  };
+  readonly codex: {
+    version: 1;
+    stores: [NativeSessionStore, NativeSessionStore];
+    identity: {
+      kind: "first-event";
+      event: string;
+      deadlineMs: number;
+    };
+    resume: {
+      kind: "args";
+      args: string[];
+    };
+    forbiddenArgs: string[];
+    storeEnv: {
+      CODEX_HOME: string;
+    };
+    evidence: {
+      servedModel: "turn-context";
+      usage: "cumulative";
+      endingError: "session-record";
+    };
+    cliVersion: "0.164.0";
+  };
+  readonly opencode: {
+    version: 1;
+    stores: [{
+      root: string;
+      files: string[];
+      write: "sqlite-wal";
+      shared: true;
+      format: "opencode.sqlite";
+    }];
+    identity: {
+      kind: "first-event";
+      event: string;
+      deadlineMs: number;
+    };
+    resume: {
+      kind: "args";
+      args: string[];
+    };
+    forbiddenArgs: never[];
+    storeEnv: {
+      XDG_DATA_HOME: string;
+    };
+    evidence: {
+      servedModel: "turn-context";
+      usage: "per-response";
+      endingError: "session-record";
+    };
+    cliVersion: "1.19.4";
+  };
+  readonly pi: {
+    version: 1;
+    stores: [{
+      root: string;
+      files: string[];
+      write: "jsonl-append";
+      shared: false;
+      format: "pi.session-jsonl";
+    }];
+    identity: {
+      kind: "pre-minted";
+      args: string[];
+    };
+    resume: {
+      kind: "args";
+      args: string[];
+    };
+    forbiddenArgs: string[];
+    storeEnv: {
+      PI_CODING_AGENT_DIR: string;
+      PI_CODING_AGENT_SESSION_DIR: string;
+      "--session-dir": string;
+    };
+    evidence: {
+      servedModel: "session-record";
+      usage: "per-response";
+      endingError: "session-record";
+    };
+    cliVersion: "1.4.0";
+  };
+  readonly "kimi-code": {
+    version: 1;
+    stores: [NativeSessionStore];
+    identity: {
+      kind: "pre-minted";
+      args: string[];
+    };
+    resume: {
+      kind: "args";
+      args: string[];
+    };
+    forbiddenArgs: never[];
+    storeEnv: {};
+    evidence: {
+      servedModel: "session-record";
+      usage: "per-response";
+      endingError: "none";
+    };
+    cliVersion: "1.49.0";
+  };
+  readonly "factory-droids": {
+    version: 1;
+    stores: [{
+      root: string;
+      files: string[];
+      write: "jsonl-append";
+      shared: false;
+      format: "factory.session-jsonl";
+    }, {
+      root: string;
+      files: string[];
+      write: "json-rewrite";
+      shared: false;
+      format: "factory.session-jsonl";
+    }];
+    identity: {
+      kind: "first-event";
+      event: string;
+      deadlineMs: number;
+    };
+    resume: {
+      kind: "args";
+      args: string[];
+    };
+    forbiddenArgs: never[];
+    storeEnv: {};
+    evidence: {
+      servedModel: "turn-context";
+      usage: "session-total";
+      endingError: "none";
+    };
+    cliVersion: "0.249.0";
+  };
+  readonly amp: {
+    version: 1;
+    stores: [{
+      root: string;
+      files: string[];
+      write: "json-rewrite";
+      shared: false;
+      format: "amp.thread-json";
+    }];
+    identity: {
+      kind: "first-event";
+      event: string;
+      deadlineMs: number;
+    };
+    resume: {
+      kind: "args";
+      args: string[];
+    };
+    forbiddenArgs: never[];
+    storeEnv: {
+      XDG_DATA_HOME: string;
+    };
+    evidence: {
+      servedModel: "session-record";
+      usage: "per-response";
+      endingError: "none";
+    };
+    cliVersion: "0.0.1793044831-ga1b1a0";
+  };
+  readonly prime: {
+    version: 1;
+    stores: [{
+      root: string;
+      files: string[];
+      write: "jsonl-append";
+      shared: false;
+      format: "prime.session-jsonl";
+    }];
+    identity: {
+      kind: "api-created";
+      call: "acp session/new";
+    };
+    resume: {
+      kind: "api";
+    };
+    forbiddenArgs: string[];
+    storeEnv: {};
+    evidence: {
+      servedModel: "session-record";
+      usage: "per-response";
+      endingError: "session-record";
+    };
+    cliVersion: "0.10.1";
+  };
+  readonly hermes: {
+    version: 1;
+    stores: [NativeSessionStore];
+    identity: {
+      kind: "first-event";
+      event: string;
+      deadlineMs: number;
+    };
+    resume: {
+      kind: "args";
+      args: string[];
+    };
+    forbiddenArgs: never[];
+    storeEnv: {
+      HERMES_HOME: string;
+    };
+    evidence: {
+      servedModel: "session-record";
+      usage: "session-total";
+      endingError: "none";
+    };
+    cliVersion: "0.22.4";
+  };
+  readonly forge: {
+    version: 1;
+    stores: [{
+      root: string;
+      files: string[];
+      write: "sqlite-wal";
+      shared: true;
+      format: "forge.sqlite";
+    }];
+    identity: {
+      kind: "first-event";
+      event: string;
+      deadlineMs: number;
+    };
+    resume: {
+      kind: "args";
+      args: string[];
+    };
+    forbiddenArgs: never[];
+    storeEnv: {};
+    evidence: {
+      servedModel: "session-record";
+      usage: "per-response";
+      endingError: "none";
+    };
+    cliVersion: "2.14.0";
+  };
+  readonly openclaw: {
+    version: 1;
+    stores: [{
+      root: string;
+      files: string[];
+      write: "jsonl-append";
+      shared: false;
+      format: "openclaw.session-jsonl";
+    }];
+    identity: {
+      kind: "first-event";
+      event: string;
+      deadlineMs: number;
+    };
+    resume: {
+      kind: "args";
+      args: string[];
+    };
+    forbiddenArgs: never[];
+    storeEnv: {};
+    evidence: {
+      servedModel: "session-record";
+      usage: "per-response";
+      endingError: "none";
+    };
+    cliVersion: "2026.10.7";
+  };
+  readonly acp: {
+    version: 1;
+    stores: [NativeSessionStore, NativeSessionStore, NativeSessionStore, NativeSessionStore, NativeSessionStore];
+    identity: {
+      kind: "api-created";
+      call: "acp session/new";
+    };
+    resume: {
+      kind: "api";
+    };
+    forbiddenArgs: never[];
+    storeEnv: {};
+    evidence: {
+      servedModel: "session-record";
+      usage: "per-response";
+      endingError: "none";
+    };
+    cliVersion: "claude-agent-acp 0.97.0; codex-acp 0.16.0; gemini-cli 0.65.0";
+  };
+};
+/**
+ * The child environment of a harness whose contract can move every native
+ * store off HOME, or undefined when it cannot.
+ *
+ * HOME becomes the shared agent home, so toolchains and repos the agent puts
+ * under ~ persist across sessions and restarts. Each declared store env and
+ * the XDG roots stay in the private runtime home, so credentials, config and
+ * session records do not collide between sessions. A harness whose contract
+ * declares no store env (kimi-code, factory-droids, forge, openclaw, acp,
+ * prime) writes credentials straight under HOME and keeps the private HOME.
+ * So does OpenCode: its warm-server pool, spare adoption, plugin dependencies
+ * and correlation file all use HOME as the session's runtime identity, and a
+ * shared HOME would merge those identities across sessions.
+ */
+declare function configDirHomeEnv(harness: string, runtimeHome: string, agentHome: string): Record<string, string> | undefined;
+/**
+ * Harnesses whose declared contract has no conformance receipt yet, with
+ * the reason. They keep running with persistence-disabling flags refused,
+ * but the store-location and identity-deadline checks wait for their
+ * receipt. This list may only shrink: tests/harness-session-contract.test.ts
+ * fails on a new entry, and on an entry whose receipt now passes.
+ */
+declare const HARNESS_CONFORMANCE_PENDING: Readonly<Record<string, string>>;
+/**
+ * Harnesses that cannot meet the contract at all. They stay listed until
+ * their product surfaces (sandbox web launch list, CLI connect, SDK
+ * placement) drop them, and no capture claims their sessions.
+ */
+declare const HARNESS_SESSION_UNSUPPORTED: Readonly<Record<string, string>>;
+//#endregion
+export { HARNESS_CONFORMANCE_PENDING, HARNESS_SESSION_UNSUPPORTED, NATIVE_SESSION_CONTRACTS, configDirHomeEnv };
+//# sourceMappingURL=native-session-contracts.d.mts.map

package/dist/native-session-contracts.mjs

@@ -0,0 +1,2 @@
+import { i as configDirHomeEnv, n as HARNESS_SESSION_UNSUPPORTED, r as NATIVE_SESSION_CONTRACTS, t as HARNESS_CONFORMANCE_PENDING } from "./native-session-contracts-DWFzgoye.mjs";
+export { HARNESS_CONFORMANCE_PENDING, HARNESS_SESSION_UNSUPPORTED, NATIVE_SESSION_CONTRACTS, configDirHomeEnv };

package/dist/servable-models.d.mts

@@ -0,0 +1,104 @@
+import { HarnessModelSupportOptions } from "@tangle-network/agent-interface/harness-capabilities";
+
+//#region src/servable-models.d.ts
+/** One reviewed rung of {@link MANAGED_MODEL_LADDER}. */
+interface ManagedModelRung {
+  /** Provider-qualified id the Tangle Router routes verbatim. */
+  id: string;
+  /** Why this rung sits where it does: serving state and price when reviewed. */
+  reason: string;
+  /** ISO date the rung was checked against the live `GET /v1/models`. */
+  reviewedAt: string;
+}
+/**
+ * The models a managed (Tangle-funded) run may default to, most preferred
+ * first. Every managed default in the platform is the first rung a harness can
+ * run ({@link managedModelChain}), so this list is the one place a default
+ * model is chosen.
+ *
+ * A managed run sends its model id to the Tangle router, which answers only
+ * when BOTH of these hold:
+ *
+ *   1. the router routes the id — it appears in `GET /v1/models` with
+ *      `routeability.routeable = true`; and
+ *   2. the router holds a spend-authorizing price for the id — a
+ *      `ProviderPriceVersion` row whose `authority` is `provider_official` or
+ *      `operator_reviewed`. Third-party price observations are recorded but
+ *      cannot authorize spend, so they do not count.
+ *
+ * A model that fails either test answers 503 `provider_pricing_unavailable`
+ * to a Tangle-funded call. A CLI reads 503 as transient and retries until its
+ * own timeout, so the run produces no output and no error for many minutes.
+ * That is why an unservable default is worse than a wrong one: it does not
+ * fail, it hangs.
+ *
+ * Which models a harness can run is not decided here: the capability table
+ * ({@link harnessModelSupportFor}) drops the rungs a harness refuses (a vendor
+ * lock, measured exclusions). claude-code and codex run the whole ladder: the
+ * router translates every non-vendor model on their Messages and Responses
+ * wires to chat completions, so they lead with the same cheapest rung as every
+ * other Router-backed harness. A rung exists for a vendor-locked harness when
+ * it is the only model that harness can run (kimi-code runs Moonshot).
+ */
+declare const MANAGED_MODEL_LADDER: readonly ManagedModelRung[];
+/** The bare id a provider-prefixed model id carries. */
+declare function bareModelId(modelId: string): string;
+/**
+ * Whether a managed default may use this id. Accepts the provider-prefixed
+ * form and the bare form, because a harness on a provider-native wire sends
+ * the bare id its own CLI expects.
+ */
+declare function isServableManagedModel(modelId: string): boolean;
+interface ManagedModelChainOptions {
+  /**
+   * The model the caller or its profile named. It is returned alone and never
+   * substituted: a named model that cannot run fails loud where it is checked.
+   */
+  named?: string;
+  /**
+   * The operator's configured model (a deployment's `OPENCODE_MODEL_NAME` or
+   * `TANGLE_ROUTER_MODEL`), tried ahead of the ladder when the harness runs it.
+   */
+  operatorModel?: string;
+  /** The run's reasoning effort; some harness × model pairs fail only with one. */
+  reasoningEffort?: HarnessModelSupportOptions["reasoningEffort"];
+  /**
+   * The models the box's Router key allows (Platform's `allowedModels` on the
+   * minted key); absent or null allows every model. A default the key refuses
+   * fails the box's first turn with `model_not_allowed`, so the chain keeps
+   * only allowed ladder rungs, spelled as the key spells them, then the key's
+   * other models.
+   */
+  allowedModels?: readonly string[] | null;
+}
+/** A model the chain left out, and why. */
+interface SkippedManagedModel {
+  id: string;
+  reason: string;
+}
+type ManagedModelChain = {
+  ok: true;
+  chain: string[];
+  skipped: SkippedManagedModel[];
+} | {
+  ok: false;
+  chain: [];
+  skipped: SkippedManagedModel[]; /** One sentence a create or run refusal can show as-is. */
+  message: string;
+};
+/**
+ * The ordered models a managed run of `harness` may use, first choice first.
+ * Every managed default site takes `chain[0]`; the rest is the order a later
+ * fallback would try.
+ *
+ * - A named model is the whole chain.
+ * - A harness the Router cannot serve (`CliAgentSpec.callerCredentialOnly`)
+ *   has no managed chain: its CLI calls its vendor's own service, so it runs
+ *   only on the caller's own credential.
+ * - Otherwise the operator's model, then {@link MANAGED_MODEL_LADDER}, keeping
+ *   only the ids the capability table lets this harness run.
+ */
+declare function managedModelChain(harness: string, options?: ManagedModelChainOptions): ManagedModelChain;
+//#endregion
+export { MANAGED_MODEL_LADDER, ManagedModelChain, ManagedModelChainOptions, ManagedModelRung, SkippedManagedModel, bareModelId, isServableManagedModel, managedModelChain };
+//# sourceMappingURL=servable-models.d.mts.map

package/dist/servable-models.mjs

@@ -0,0 +1,147 @@
+import { l as getSpec, m as harnessModelSupportFor } from "./specs-Bbiay_8K.mjs";
+//#region src/servable-models.ts
+/**
+* The models a managed (Tangle-funded) run may default to, most preferred
+* first. Every managed default in the platform is the first rung a harness can
+* run ({@link managedModelChain}), so this list is the one place a default
+* model is chosen.
+*
+* A managed run sends its model id to the Tangle router, which answers only
+* when BOTH of these hold:
+*
+*   1. the router routes the id — it appears in `GET /v1/models` with
+*      `routeability.routeable = true`; and
+*   2. the router holds a spend-authorizing price for the id — a
+*      `ProviderPriceVersion` row whose `authority` is `provider_official` or
+*      `operator_reviewed`. Third-party price observations are recorded but
+*      cannot authorize spend, so they do not count.
+*
+* A model that fails either test answers 503 `provider_pricing_unavailable`
+* to a Tangle-funded call. A CLI reads 503 as transient and retries until its
+* own timeout, so the run produces no output and no error for many minutes.
+* That is why an unservable default is worse than a wrong one: it does not
+* fail, it hangs.
+*
+* Which models a harness can run is not decided here: the capability table
+* ({@link harnessModelSupportFor}) drops the rungs a harness refuses (a vendor
+* lock, measured exclusions). claude-code and codex run the whole ladder: the
+* router translates every non-vendor model on their Messages and Responses
+* wires to chat completions, so they lead with the same cheapest rung as every
+* other Router-backed harness. A rung exists for a vendor-locked harness when
+* it is the only model that harness can run (kimi-code runs Moonshot).
+*/
+const MANAGED_MODEL_LADDER = [
+	{
+		id: "google/gemini-2.5-flash-lite",
+		reason: "available, $0.10/$0.40 per Mtok; the production canary passes on it",
+		reviewedAt: "2026-10-14"
+	},
+	{
+		id: "zai/glm-5.3",
+		reason: "degraded but served by zai direct (200 on chat/completions)",
+		reviewedAt: "2026-10-14"
+	},
+	{
+		id: "google/gemini-2.5-flash",
+		reason: "available",
+		reviewedAt: "2026-10-14"
+	},
+	{
+		id: "deepseek/deepseek-chat",
+		reason: "routeable and priced; no recent dispatch",
+		reviewedAt: "2026-10-14"
+	},
+	{
+		id: "moonshot/kimi-k3",
+		reason: "kimi-code's first rung (Moonshot-locked); Moonshot and Together quota-exhausted when reviewed",
+		reviewedAt: "2026-10-14"
+	},
+	{
+		id: "moonshot/kimi-k2.7-code",
+		reason: "Moonshot direct coding model; quota-exhausted when reviewed",
+		reviewedAt: "2026-10-14"
+	},
+	{
+		id: "moonshotai/kimi-k2-0905",
+		reason: "served through OpenRouter; no recent dispatch",
+		reviewedAt: "2026-10-14"
+	},
+	{
+		id: "openai/gpt-6-luna",
+		reason: "the router's tangle/cheap role; no recent dispatch",
+		reviewedAt: "2026-10-14"
+	}
+];
+/** The bare id a provider-prefixed model id carries. */
+function bareModelId(modelId) {
+	const slash = modelId.lastIndexOf("/");
+	return slash < 0 ? modelId : modelId.slice(slash + 1);
+}
+/**
+* Whether a managed default may use this id. Accepts the provider-prefixed
+* form and the bare form, because a harness on a provider-native wire sends
+* the bare id its own CLI expects.
+*/
+function isServableManagedModel(modelId) {
+	const candidate = modelId.trim();
+	if (!candidate) return false;
+	const bare = bareModelId(candidate);
+	return MANAGED_MODEL_LADDER.some((rung) => rung.id === candidate || bareModelId(rung.id) === bare);
+}
+/**
+* The ordered models a managed run of `harness` may use, first choice first.
+* Every managed default site takes `chain[0]`; the rest is the order a later
+* fallback would try.
+*
+* - A named model is the whole chain.
+* - A harness the Router cannot serve (`CliAgentSpec.callerCredentialOnly`)
+*   has no managed chain: its CLI calls its vendor's own service, so it runs
+*   only on the caller's own credential.
+* - Otherwise the operator's model, then {@link MANAGED_MODEL_LADDER}, keeping
+*   only the ids the capability table lets this harness run.
+*/
+function managedModelChain(harness, options = {}) {
+	if (getSpec(harness)?.callerCredentialOnly) return {
+		ok: false,
+		chain: [],
+		skipped: [],
+		message: `${harness} cannot run on Tangle Router: its CLI calls its vendor's own service, so it runs only on the caller's own credential.`
+	};
+	const named = options.named?.trim();
+	if (named) return {
+		ok: true,
+		chain: [named],
+		skipped: []
+	};
+	const preferred = [options.operatorModel?.trim(), ...MANAGED_MODEL_LADDER.map((rung) => rung.id)].filter((id) => Boolean(id));
+	const allowed = options.allowedModels?.map((id) => id.trim()).filter(Boolean);
+	const candidates = allowed ? [...preferred.flatMap((id) => {
+		const match = allowed.find((entry) => entry === id) ?? allowed.find((entry) => bareModelId(entry) === bareModelId(id));
+		return match ? [match] : [];
+	}), ...allowed] : preferred;
+	const chain = [];
+	const skipped = [];
+	for (const id of new Set(candidates)) {
+		const support = harnessModelSupportFor(harness, id, { reasoningEffort: options.reasoningEffort });
+		if (support.supported) chain.push(id);
+		else skipped.push({
+			id,
+			reason: support.message
+		});
+	}
+	if (chain.length > 0) return {
+		ok: true,
+		chain,
+		skipped
+	};
+	return {
+		ok: false,
+		chain: [],
+		skipped,
+		message: `No managed model can run on ${harness}: ` + skipped.map((entry) => `${entry.id} (${entry.reason})`).join("; ")
+	};
+}
+//#endregion
+export { MANAGED_MODEL_LADDER, bareModelId, isServableManagedModel, managedModelChain };
+
+//# sourceMappingURL=servable-models.mjs.map