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

package/dist/servable-models.mjs

@@ -0,0 +1,131 @@
+import { l as getSpec, m as harnessModelSupportFor } from "./specs-BBF55TnM.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 (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.
+*/
+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: "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

package/dist/session-contract-BhzcbPRW.d.mts

@@ -0,0 +1,97 @@
+//#region src/session-contract.d.ts
+/** One session contract. Stores sit under the private runtime HOME. No Node built-ins. */
+declare const SESSION_FORMAT_IDS: readonly ["claude-code.projects-jsonl", "codex.rollout-jsonl", "opencode.sqlite", "pi.session-jsonl", "kimi.session-dir", "factory.session-jsonl", "gemini.chat-json", "amp.thread-json", "hermes.state-sqlite", "prime.session-jsonl", "openclaw.session-jsonl", "grok.acp-session-dir", "nanoclaw.session-sqlite", "sidecar.message-json", "sidecar.session-json"];
+type SessionFormatId = (typeof SESSION_FORMAT_IDS)[number];
+interface NativeSessionStore {
+  /**
+   * Relative to the execution's private runtime HOME. Normalized, with no
+   * `..`; never absolute and never in the workspace.
+   */
+  root: string;
+  /** Globs under root that hold one session. `{id}` is the native session id. */
+  files: readonly string[];
+  /** How the harness writes. This decides how a copy is taken while it runs. */
+  write: "jsonl-append" | "json-rewrite" | "sqlite-wal";
+  /** True when one store holds every session in the HOME (opencode.db). Readers select by id. */
+  shared: boolean;
+  format: SessionFormatId;
+}
+type NativeSessionIdentity = /** The sidecar mints the id and records it before it spawns the CLI. */{
+  kind: "pre-minted";
+  args: readonly string[];
+} /** The id comes from an API call that precedes the first prompt. */ | {
+  kind: "api-created";
+  call: "opencode POST /session" | "acp session/new" | "codex thread/start" | "amp threads new";
+}
+/**
+ * Only for a CLI that cannot accept an id: the id is the first event's.
+ * Past the deadline the attempt fails with `native_session_id_unobserved`.
+ */
+| {
+  kind: "first-event";
+  event: string;
+  deadlineMs: number;
+};
+interface HarnessSessionEvidence {
+  servedModel: "provider-response" | "session-record" | "turn-context" | "none";
+  usage: "per-response" | "cumulative" | "session-total" | "none";
+  endingError: "session-record" | "none";
+}
+interface HarnessSessionContract {
+  version: 1;
+  stores: readonly [NativeSessionStore, ...NativeSessionStore[]];
+  identity: NativeSessionIdentity;
+  resume: {
+    kind: "args";
+    args: readonly string[];
+  } | {
+    kind: "api";
+  };
+  /**
+   * Argv tokens that disable or redirect persistence. Refused in config
+   * extraFlags, in profile flags and in the built argv. A token also matches
+   * its `--flag=value` form.
+   */
+  forbiddenArgs: readonly string[];
+  /**
+   * Env names, and flags such as `--session-dir`, that move the store, each
+   * mapped to the only path it may take, relative to the runtime HOME.
+   */
+  storeEnv: Readonly<Record<string, string>>;
+  evidence: HarnessSessionEvidence;
+  /** The pinned CLI version (infra/nix) that the conformance receipt covers. */
+  cliVersion: string;
+}
+type HarnessSessionContractErrorCode = "harness_session_contract_missing" | "harness_session_persistence_disabled" | "harness_conformance_missing" | "native_session_id_unobserved";
+declare class HarnessSessionContractError extends Error {
+  readonly code: HarnessSessionContractErrorCode;
+  constructor(code: HarnessSessionContractErrorCode, message: string);
+}
+/** Replace `{id}` in each token. */
+declare function substituteNativeSessionId(tokens: readonly string[], nativeSessionId: string): string[];
+/** The forbidden tokens present in `argv`, in argv order. */
+declare function forbiddenArgViolations(contract: Pick<HarnessSessionContract, "forbiddenArgs">, argv: readonly string[]): string[];
+/** Refuse flags that disable persistence, on configured flags and on the built argv. */
+declare function assertFlagsHonourSessionContract(harness: string, contract: Pick<HarnessSessionContract, "forbiddenArgs">, flags: readonly string[], source: string): void;
+/** No forbidden argv token, and a pre-minted new session carries its minted id. */
+declare function assertArgvHonoursSessionContract(harness: string, contract: HarnessSessionContract, argv: readonly string[], session: {
+  mintedId?: string;
+}): void;
+/** Normalize a POSIX path; `..` that escapes the start is kept as a leading `..`. */
+declare function normalizePosixPath(path: string): string;
+/** Each store env or `--flag` value must resolve to exactly HOME/<declared path>. */
+declare function assertStoreLocationHonoursSessionContract(harness: string, contract: Pick<HarnessSessionContract, "storeEnv">, input: {
+  runtimeHome: string;
+  cwd: string;
+  env?: Readonly<Record<string, string | undefined>>;
+  argv?: readonly string[];
+}): void;
+/** `**` is any number of segments, `*` is one segment, `{id}` is the session id. */
+declare function compileSessionStoreGlob(glob: string, nativeSessionId?: string): RegExp;
+/** The store that holds `pathFromHome`, or undefined. A shared store matches every session. */
+declare function sessionStoreForPath(contract: Pick<HarnessSessionContract, "stores">, pathFromHome: string, nativeSessionId: string): NativeSessionStore | undefined;
+/** Structural checks every declared contract must pass. */
+declare function sessionContractProblems(contract: HarnessSessionContract): string[];
+//#endregion
+export { substituteNativeSessionId as _, NativeSessionIdentity as a, SessionFormatId as c, assertStoreLocationHonoursSessionContract as d, compileSessionStoreGlob as f, sessionStoreForPath as g, sessionContractProblems as h, HarnessSessionEvidence as i, assertArgvHonoursSessionContract as l, normalizePosixPath as m, HarnessSessionContractError as n, NativeSessionStore as o, forbiddenArgViolations as p, HarnessSessionContractErrorCode as r, SESSION_FORMAT_IDS as s, HarnessSessionContract as t, assertFlagsHonourSessionContract as u };
+//# sourceMappingURL=session-contract-BhzcbPRW.d.mts.map

package/dist/session-contract.d.mts

@@ -0,0 +1,2 @@
+import { _ as substituteNativeSessionId, a as NativeSessionIdentity, c as SessionFormatId, d as assertStoreLocationHonoursSessionContract, f as compileSessionStoreGlob, g as sessionStoreForPath, h as sessionContractProblems, i as HarnessSessionEvidence, l as assertArgvHonoursSessionContract, m as normalizePosixPath, n as HarnessSessionContractError, o as NativeSessionStore, p as forbiddenArgViolations, r as HarnessSessionContractErrorCode, s as SESSION_FORMAT_IDS, t as HarnessSessionContract, u as assertFlagsHonourSessionContract } from "./session-contract-BhzcbPRW.mjs";
+export { HarnessSessionContract, HarnessSessionContractError, HarnessSessionContractErrorCode, HarnessSessionEvidence, NativeSessionIdentity, NativeSessionStore, SESSION_FORMAT_IDS, SessionFormatId, assertArgvHonoursSessionContract, assertFlagsHonourSessionContract, assertStoreLocationHonoursSessionContract, compileSessionStoreGlob, forbiddenArgViolations, normalizePosixPath, sessionContractProblems, sessionStoreForPath, substituteNativeSessionId };

package/dist/session-contract.mjs

@@ -0,0 +1,142 @@
+//#region src/session-contract.ts
+/** One session contract. Stores sit under the private runtime HOME. No Node built-ins. */
+const SESSION_FORMAT_IDS = [
+	"claude-code.projects-jsonl",
+	"codex.rollout-jsonl",
+	"opencode.sqlite",
+	"pi.session-jsonl",
+	"kimi.session-dir",
+	"factory.session-jsonl",
+	"gemini.chat-json",
+	"amp.thread-json",
+	"hermes.state-sqlite",
+	"prime.session-jsonl",
+	"openclaw.session-jsonl",
+	"grok.acp-session-dir",
+	"nanoclaw.session-sqlite",
+	"sidecar.message-json",
+	"sidecar.session-json"
+];
+var HarnessSessionContractError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(`${code}: ${message}`);
+		this.name = "HarnessSessionContractError";
+		this.code = code;
+	}
+};
+/** Replace `{id}` in each token. */
+function substituteNativeSessionId(tokens, nativeSessionId) {
+	return tokens.map((token) => token.split("{id}").join(nativeSessionId));
+}
+/** The forbidden tokens present in `argv`, in argv order. */
+function forbiddenArgViolations(contract, argv) {
+	return argv.filter((token) => contract.forbiddenArgs.some((forbidden) => token === forbidden || token.startsWith(`${forbidden}=`)));
+}
+function indexOfSequence(haystack, needle) {
+	if (needle.length === 0) return 0;
+	for (let index = 0; index + needle.length <= haystack.length; index++) if (needle.every((token, offset) => haystack[index + offset] === token)) return index;
+	return -1;
+}
+/** Refuse flags that disable persistence, on configured flags and on the built argv. */
+function assertFlagsHonourSessionContract(harness, contract, flags, source) {
+	const violations = forbiddenArgViolations(contract, flags);
+	if (violations.length > 0) throw new HarnessSessionContractError("harness_session_persistence_disabled", `${harness} ${source} carries ${violations.join(", ")}, which disables or redirects its native session`);
+}
+/** No forbidden argv token, and a pre-minted new session carries its minted id. */
+function assertArgvHonoursSessionContract(harness, contract, argv, session) {
+	assertFlagsHonourSessionContract(harness, contract, argv, "argv");
+	if (session.mintedId === void 0) return;
+	if (contract.identity.kind !== "pre-minted") throw new HarnessSessionContractError("harness_session_persistence_disabled", `${harness} was given a minted session id but its identity is ${contract.identity.kind}`);
+	if (indexOfSequence(argv, substituteNativeSessionId(contract.identity.args, session.mintedId)) < 0) throw new HarnessSessionContractError("harness_session_persistence_disabled", `${harness} argv does not carry its pre-minted session id (${contract.identity.args.join(" ")})`);
+}
+/** Normalize a POSIX path; `..` that escapes the start is kept as a leading `..`. */
+function normalizePosixPath(path) {
+	const absolute = path.startsWith("/");
+	const parts = [];
+	for (const part of path.split("/")) {
+		if (part === "" || part === ".") continue;
+		if (part === "..") {
+			if (parts.length > 0 && parts[parts.length - 1] !== "..") parts.pop();
+			else if (!absolute) parts.push("..");
+			continue;
+		}
+		parts.push(part);
+	}
+	const joined = parts.join("/");
+	return absolute ? `/${joined}` : joined || ".";
+}
+function resolvePosix(base, value) {
+	return normalizePosixPath(value.startsWith("/") ? value : `${base.replace(/\/+$/u, "")}/${value}`);
+}
+/** Each store env or `--flag` value must resolve to exactly HOME/<declared path>. */
+function assertStoreLocationHonoursSessionContract(harness, contract, input) {
+	const home = normalizePosixPath(input.runtimeHome);
+	const violations = [];
+	for (const [name, declared] of Object.entries(contract.storeEnv)) {
+		const expected = resolvePosix(home, declared);
+		const values = [];
+		if (name.startsWith("--")) {
+			const argv = input.argv ?? [];
+			for (let index = 0; index < argv.length; index++) {
+				const token = argv[index];
+				if (token === name && index + 1 < argv.length) values.push(argv[index + 1]);
+				else if (token.startsWith(`${name}=`)) values.push(token.slice(name.length + 1));
+			}
+		} else {
+			const value = input.env?.[name];
+			if (value !== void 0 && value !== "") values.push(value);
+		}
+		for (const value of values) if (resolvePosix(input.cwd, value) !== expected) violations.push(`${name}=${value} (declared ${expected})`);
+	}
+	if (violations.length > 0) throw new HarnessSessionContractError("harness_session_persistence_disabled", `${harness} moves its native session store outside the declared location: ${violations.join("; ")}`);
+}
+function escapeRegExp(text) {
+	return text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+/** `**` is any number of segments, `*` is one segment, `{id}` is the session id. */
+function compileSessionStoreGlob(glob, nativeSessionId) {
+	const pattern = glob.replace(/\*\*\/|\*\*|\{id\}|\*|[\s\S]/gu, (token) => {
+		if (token === "{id}") return nativeSessionId === void 0 ? "[^/]+" : escapeRegExp(nativeSessionId);
+		if (token.startsWith("**")) return token === "**/" ? "(?:[^/]+/)*" : ".*";
+		return token === "*" ? "[^/]*" : escapeRegExp(token);
+	});
+	return new RegExp(`^${pattern}$`, "u");
+}
+/** The store that holds `pathFromHome`, or undefined. A shared store matches every session. */
+function sessionStoreForPath(contract, pathFromHome, nativeSessionId) {
+	const path = normalizePosixPath(pathFromHome);
+	for (const store of contract.stores) {
+		const root = normalizePosixPath(store.root);
+		if (!path.startsWith(`${root}/`)) continue;
+		const rest = path.slice(root.length + 1);
+		const id = store.shared ? void 0 : nativeSessionId;
+		if (store.files.some((glob) => compileSessionStoreGlob(glob, id).test(rest))) return store;
+	}
+}
+/** Structural checks every declared contract must pass. */
+function sessionContractProblems(contract) {
+	const problems = [];
+	if (contract.version !== 1) problems.push("version must be 1");
+	if (!contract.cliVersion.trim()) problems.push("cliVersion is empty");
+	for (const store of contract.stores) {
+		const root = normalizePosixPath(store.root);
+		if (store.root.startsWith("/") || root.startsWith("..") || root === ".") problems.push(`store root ${store.root} is not a relative path under HOME`);
+		if (root !== store.root) problems.push(`store root ${store.root} is not normalized`);
+		if (!SESSION_FORMAT_IDS.includes(store.format)) problems.push(`store format ${store.format} is unknown`);
+		if (store.files.length === 0) problems.push(`store ${store.root} declares no files`);
+		if (!store.shared && !store.files.every((glob) => glob.includes("{id}"))) problems.push(`store ${store.root} is per-session but a glob lacks {id}`);
+	}
+	if (contract.identity.kind === "pre-minted" && !contract.identity.args.some((token) => token.includes("{id}"))) problems.push("pre-minted identity args lack {id}");
+	if (contract.resume.kind === "args" && !contract.resume.args.some((token) => token.includes("{id}"))) problems.push("resume args lack {id}");
+	if (contract.identity.kind === "first-event" && !(contract.identity.deadlineMs > 0)) problems.push("first-event identity needs a positive deadline");
+	for (const [name, declared] of Object.entries(contract.storeEnv)) {
+		const normalized = normalizePosixPath(declared);
+		if (declared.startsWith("/") || normalized.startsWith("..")) problems.push(`storeEnv ${name} must name a path under HOME`);
+	}
+	return problems;
+}
+//#endregion
+export { HarnessSessionContractError, SESSION_FORMAT_IDS, assertArgvHonoursSessionContract, assertFlagsHonourSessionContract, assertStoreLocationHonoursSessionContract, compileSessionStoreGlob, forbiddenArgViolations, normalizePosixPath, sessionContractProblems, sessionStoreForPath, substituteNativeSessionId };
+
+//# sourceMappingURL=session-contract.mjs.map