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

package/dist/index.mjs

@@ -0,0 +1,151 @@
+import { t as HARNESSES } from "./harness-contracts-BZoECCMc.mjs";
+import { HARNESS_SESSION_UNSUPPORTED, NATIVE_SESSION_CONTRACTS, configDirHomeEnv } from "./native-session-contracts.mjs";
+import { HarnessSessionContractError, SESSION_FORMAT_IDS, assertArgvHonoursSessionContract, assertFlagsHonourSessionContract, assertStoreLocationHonoursSessionContract, compileSessionStoreGlob, forbiddenArgViolations, normalizePosixPath, sessionContractProblems, sessionStoreForPath, substituteNativeSessionId } from "./session-contract.mjs";
+import { a as parseBackendType, i as isBackendType, n as BACKEND_TYPE, r as backendTypeSchema, t as ALL_BACKEND_TYPES } from "./backend-types-CNo_Zj_K.mjs";
+import { a as agentProfileSchema, c as cliAgentHostPassthroughEnvVarNames, d as canonicalModelSlug, f as cliAgentClaimEnvVarNames, g as SYNTHETIC_ROUTER_MODEL, h as harnessModelWire, i as MANAGED_MODEL_KEY_NAME_ENV_VAR, l as getSpec, m as harnessModelSupportFor, n as CLI_AGENT_SPECS, o as claimDeliverableEnvVarNames, p as cliAgentEnvRoleName, r as MANAGED_MODEL_KEY_ENV_VAR, s as cliAgentEnvVarNamesByRole, t as AGENT_BACKEND_ENV_VAR, u as messageStorageDirOf } from "./specs-BBF55TnM.mjs";
+import { a as materializeCliAuthBundle } from "./cli-auth-bundle-C6DtK7GX.mjs";
+import { resolveDefaultBackend } from "./default-backend.mjs";
+import { describeLocalCliAuthExpectation, discoverLocalCliAuthFiles } from "./local-cli-auth.mjs";
+import { MANAGED_MODEL_LADDER, bareModelId, isServableManagedModel, managedModelChain } from "./servable-models.mjs";
+import { sha256DigestSchema } from "@tangle-network/agent-interface";
+import { z } from "zod";
+//#region src/adapter-bindings.ts
+/**
+* A composition-owned factory map. Wiring requirements come from this selected
+* catalog, not every harness known elsewhere. No provider implementation is
+* imported here, and separate registries cannot overwrite each other's bindings.
+*
+* Registration itself does not authorize execution. As with the existing API,
+* factories may be staged before catalog admission; callers must still resolve
+* a selected spec and enforce its capabilities before dispatching a request.
+* Unregistering a required factory is not retirement: select a new composition
+* after draining its sessions rather than weakening the wiring invariant.
+*/
+function createAdapterRegistry(specs) {
+	const selected = /* @__PURE__ */ new Map();
+	for (const spec of specs) {
+		if (selected.has(spec.name)) throw new Error(`cli-agent-registry: duplicate spec "${spec.name}"`);
+		selected.set(spec.name, {
+			sessions: spec.capabilities.sessions,
+			nativeSession: spec.nativeSession != null
+		});
+	}
+	const factories = /* @__PURE__ */ new Map();
+	function assertSessionContractDeclared(name) {
+		const spec = selected.get(name);
+		if (!spec?.sessions || spec.nativeSession) return;
+		if (Object.hasOwn(HARNESS_SESSION_UNSUPPORTED, name)) return;
+		throw new HarnessSessionContractError("harness_session_contract_missing", `${name} runs sessions but declares no nativeSession contract`);
+	}
+	return {
+		registerAdapterFactory(name, factory, options) {
+			assertSessionContractDeclared(name);
+			if (factories.has(name) && !options?.force) throw new Error(`cli-agent-registry: adapter factory for "${name}" already registered. Pass { force: true } to override (test stubs only) or call unregisterAdapterFactory() first.`);
+			factories.set(name, factory);
+		},
+		unregisterAdapterFactory(name) {
+			return factories.delete(name);
+		},
+		getAdapterFactory(name) {
+			return factories.get(name);
+		},
+		listRegisteredAdapters() {
+			return Array.from(factories.keys());
+		},
+		assertAdaptersWired() {
+			const missing = [];
+			for (const [name, spec] of selected) {
+				assertSessionContractDeclared(name);
+				if (spec.sessions && !factories.has(name)) missing.push(name);
+			}
+			if (missing.length > 0) throw new Error(`cli-agent-registry: executable backend specs without an adapter factory registered: ${missing.join(", ")}. Register each selected adapter in the composition root before startup.`);
+		}
+	};
+}
+const defaultRegistry = createAdapterRegistry(CLI_AGENT_SPECS);
+function registerAdapterFactory(name, factory, options) {
+	defaultRegistry.registerAdapterFactory(name, factory, options);
+}
+function unregisterAdapterFactory(name) {
+	return defaultRegistry.unregisterAdapterFactory(name);
+}
+function getAdapterFactory(name) {
+	return defaultRegistry.getAdapterFactory(name);
+}
+function listRegisteredAdapters() {
+	return defaultRegistry.listRegisteredAdapters();
+}
+function assertAdaptersWired() {
+	defaultRegistry.assertAdaptersWired();
+}
+//#endregion
+//#region src/agent-run-request.ts
+/** A backend carries an inline profile, a profile digest, or neither. */
+function agentRunBackendVariants(base) {
+	const profileSha256 = z.string().regex(/^[a-f0-9]{64}$/, "profileSha256 must be a lowercase SHA-256");
+	return z.union([
+		z.object({
+			...base,
+			profile: agentProfileSchema
+		}).strict(),
+		z.object({
+			...base,
+			profileSha256
+		}).strict(),
+		z.object(base).strict()
+	]);
+}
+const agentRunWorkspaceSchema = z.object({
+	rootPath: z.string().optional(),
+	debugDirectory: z.string().optional(),
+	skipInitialization: z.boolean().optional(),
+	cleanupOnShutdown: z.boolean().optional()
+});
+/** The shared request fields, in wire order around each end's workspace and backend. */
+function agentRunRequestSharedShape(workspace, backend) {
+	return {
+		sessionId: z.string().optional(),
+		displayName: z.string().optional(),
+		description: z.string().optional(),
+		domains: z.array(z.string()).optional(),
+		workspace,
+		backend,
+		expectedPublicProfileRequestDigest: sha256DigestSchema.optional(),
+		expectedPublicProfileRevision: z.object({
+			workspacePlanDigest: sha256DigestSchema,
+			materializedDigest: sha256DigestSchema,
+			launchDigest: z.string().regex(/^[a-f0-9]{64}$/)
+		}).strict().optional(),
+		expectedSecretProfileReceipt: z.string().regex(/^hmac-sha256:[a-f0-9]{64}$/).optional(),
+		githubToken: z.string().optional(),
+		metadata: z.record(z.string(), z.unknown()).optional()
+	};
+}
+//#endregion
+//#region src/cli-dir-layout.ts
+/** What every CLI's directory is read with; a spec adds its own entries. */
+const DEFAULT_CLI_DIR_LAYOUT = {
+	homeSessionData: [],
+	sessionData: ["messages/**", "history.jsonl"],
+	configAllow: [
+		"config.toml",
+		"settings.json",
+		"settings.local.json",
+		"opencode.jsonc",
+		"package.json",
+		"package-lock.json",
+		"models_cache.json",
+		"installation_id",
+		"version.json",
+		".personality_migration"
+	],
+	credential: []
+};
+/** The default layout with a spec's additions. */
+function mergeCliDirLayout(additions) {
+	return Object.fromEntries(Object.entries(DEFAULT_CLI_DIR_LAYOUT).map(([key, paths]) => [key, [...paths, ...additions?.[key] ?? []]]));
+}
+//#endregion
+export { AGENT_BACKEND_ENV_VAR, ALL_BACKEND_TYPES, BACKEND_TYPE, CLI_AGENT_SPECS, DEFAULT_CLI_DIR_LAYOUT, HARNESSES, HARNESS_SESSION_UNSUPPORTED, HarnessSessionContractError, MANAGED_MODEL_KEY_ENV_VAR, MANAGED_MODEL_KEY_NAME_ENV_VAR, MANAGED_MODEL_LADDER, NATIVE_SESSION_CONTRACTS, SESSION_FORMAT_IDS, SYNTHETIC_ROUTER_MODEL, agentProfileSchema, agentRunBackendVariants, agentRunRequestSharedShape, agentRunWorkspaceSchema, assertAdaptersWired, assertArgvHonoursSessionContract, assertFlagsHonourSessionContract, assertStoreLocationHonoursSessionContract, backendTypeSchema, bareModelId, canonicalModelSlug, claimDeliverableEnvVarNames, cliAgentClaimEnvVarNames, cliAgentEnvRoleName, cliAgentEnvVarNamesByRole, cliAgentHostPassthroughEnvVarNames, compileSessionStoreGlob, configDirHomeEnv, createAdapterRegistry, describeLocalCliAuthExpectation, discoverLocalCliAuthFiles, forbiddenArgViolations, getAdapterFactory, getSpec, harnessModelSupportFor, harnessModelWire, isBackendType, isServableManagedModel, listRegisteredAdapters, managedModelChain, materializeCliAuthBundle, mergeCliDirLayout, messageStorageDirOf, normalizePosixPath, parseBackendType, registerAdapterFactory, resolveDefaultBackend, sessionContractProblems, sessionStoreForPath, substituteNativeSessionId, unregisterAdapterFactory };
+
+//# sourceMappingURL=index.mjs.map

package/dist/local-cli-auth.d.mts

@@ -0,0 +1,14 @@
+import { i as LocalCliAuthFile } from "./cli-auth-bundle-CwAaH0Ap.mjs";
+
+//#region src/local-cli-auth.d.ts
+type LocalCliAuthBackend = "codex" | "claude-code";
+type DiscoverOptions = {
+  homeDir?: string;
+  env?: Readonly<Record<string, string | undefined>>;
+  credentialOnly?: boolean;
+};
+declare function discoverLocalCliAuthFiles(backendType: LocalCliAuthBackend, options?: DiscoverOptions): LocalCliAuthFile[] | undefined;
+declare function describeLocalCliAuthExpectation(backendType: LocalCliAuthBackend): string;
+//#endregion
+export { type LocalCliAuthFile, describeLocalCliAuthExpectation, discoverLocalCliAuthFiles };
+//# sourceMappingURL=local-cli-auth.d.mts.map

package/dist/local-cli-auth.mjs

@@ -0,0 +1,31 @@
+import { t as AUTH_BUNDLE_PATHS } from "./cli-auth-bundle-C6DtK7GX.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+//#region src/local-cli-auth.ts
+const DEFAULT_MODE = 384;
+function readAuthFile(sourcePath, targetPath) {
+	if (!existsSync(sourcePath)) return null;
+	return {
+		path: targetPath,
+		content: readFileSync(sourcePath, "utf-8"),
+		mode: DEFAULT_MODE
+	};
+}
+function discoverLocalCliAuthFiles(backendType, options = {}) {
+	const env = options.env ?? (options.homeDir === void 0 ? process.env : {});
+	const homeDir = options.homeDir ?? (env.HOME || homedir());
+	const authPath = AUTH_BUNDLE_PATHS[backendType];
+	const configDir = env[backendType === "codex" ? "CODEX_HOME" : "CLAUDE_CONFIG_DIR"] || join(homeDir, dirname(authPath));
+	const credentialDir = backendType === "claude-code" ? env.CLAUDE_SECURESTORAGE_CONFIG_DIR || configDir : configDir;
+	const authFiles = [authPath, ...backendType === "claude-code" && !options.credentialOnly ? [".claude/settings.json", ".claude/settings.local.json"] : []].map((path) => readAuthFile(join(path === authPath ? credentialDir : configDir, basename(path)), path)).filter((entry) => entry !== null);
+	return authFiles.length > 0 ? authFiles : void 0;
+}
+function describeLocalCliAuthExpectation(backendType) {
+	if (backendType === "codex") return "auth.json in CODEX_HOME, or ~/.codex when CODEX_HOME is unset";
+	return "Claude credential files in CLAUDE_SECURESTORAGE_CONFIG_DIR or CLAUDE_CONFIG_DIR (default ~/.claude)";
+}
+//#endregion
+export { describeLocalCliAuthExpectation, discoverLocalCliAuthFiles };
+
+//# sourceMappingURL=local-cli-auth.mjs.map

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

@@ -0,0 +1,349 @@
+import { o as NativeSessionStore } from "./session-contract-BhzcbPRW.mjs";
+
+//#region src/native-session-contracts.d.ts
+/** Native session contracts. A receipt proves each pin. There is no pending list. */
+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: "none";
+      usage: "per-response";
+      endingError: "session-record";
+    };
+    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.250.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.1793104576-gc52692";
+  };
+  readonly prime: {
+    version: 1;
+    stores: [{
+      root: string;
+      files: string[];
+      write: "jsonl-append";
+      shared: true;
+      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 openclaw: {
+    version: 1;
+    stores: [{
+      root: string;
+      files: string[];
+      write: "sqlite-wal";
+      shared: true;
+      format: "openclaw.session-jsonl";
+    }];
+    identity: {
+      kind: "pre-minted";
+      args: string[];
+    };
+    resume: {
+      kind: "args";
+      args: string[];
+    };
+    forbiddenArgs: never[];
+    storeEnv: {};
+    evidence: {
+      servedModel: "session-record";
+      usage: "per-response";
+      endingError: "none";
+    };
+    cliVersion: "2026.10.8";
+  };
+  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: "session-total";
+      endingError: "none";
+    };
+    cliVersion: "claude-agent-acp 0.97.0; codex-acp 0.16.0; gemini-cli 0.65.0";
+  };
+  readonly grok: {
+    version: 1;
+    stores: [{
+      root: string;
+      files: string[];
+      write: "jsonl-append";
+      shared: false;
+      format: "grok.acp-session-dir";
+    }];
+    identity: {
+      kind: "first-event";
+      event: string;
+      deadlineMs: number;
+    };
+    resume: {
+      kind: "args";
+      args: string[];
+    };
+    forbiddenArgs: never[];
+    storeEnv: {
+      GROK_HOME: string;
+    };
+    evidence: {
+      servedModel: "session-record";
+      usage: "none";
+      endingError: "none";
+    };
+    cliVersion: "0.1.220";
+  };
+  readonly nanoclaw: {
+    version: 1;
+    stores: [{
+      root: string;
+      files: string[];
+      write: "sqlite-wal";
+      shared: false;
+      format: "nanoclaw.session-sqlite";
+    }];
+    identity: {
+      kind: "first-event";
+      event: string;
+      deadlineMs: number;
+    };
+    resume: {
+      kind: "api";
+    };
+    forbiddenArgs: never[];
+    storeEnv: {
+      NANOCLAW_RUNTIME_ROOT: string;
+    };
+    evidence: {
+      servedModel: "none";
+      usage: "per-response";
+      endingError: "none";
+    };
+    cliVersion: "2.1.54";
+  };
+};
+/** Store env and XDG roots under the private runtime home. Undefined when HOME itself is the store. */
+declare function configDirHomeEnv(harness: string, runtimeHome: string, agentHome: string): Record<string, string> | undefined;
+/** No capture claims these sessions. They stay until their product surfaces drop them. */
+declare const HARNESS_SESSION_UNSUPPORTED: Readonly<Record<string, string>>;
+//#endregion
+export { HARNESS_SESSION_UNSUPPORTED, NATIVE_SESSION_CONTRACTS, configDirHomeEnv };
+//# sourceMappingURL=native-session-contracts.d.mts.map

package/dist/native-session-contracts.mjs

@@ -0,0 +1,40 @@
+import { t as HARNESSES } from "./harness-contracts-BZoECCMc.mjs";
+//#region src/native-session-contracts.ts
+/** Native session contracts. A receipt proves each pin. There is no pending list. */
+const NATIVE_SESSION_CONTRACTS = {
+	"claude-code": HARNESSES["claude-code"].session.contract,
+	codex: HARNESSES["codex"].session.contract,
+	opencode: HARNESSES["opencode"].session.contract,
+	pi: HARNESSES["pi"].session.contract,
+	"kimi-code": HARNESSES["kimi-code"].session.contract,
+	"factory-droids": HARNESSES["factory-droids"].session.contract,
+	amp: HARNESSES["amp"].session.contract,
+	prime: HARNESSES["prime"].session.contract,
+	hermes: HARNESSES["hermes"].session.contract,
+	openclaw: HARNESSES["openclaw"].session.contract,
+	acp: HARNESSES["acp"].session.contract,
+	grok: HARNESSES["grok"].session.contract,
+	nanoclaw: HARNESSES["nanoclaw"].session.contract
+};
+const HOME_KEYED_RUNTIMES = new Set(["opencode"]);
+/** Store env and XDG roots under the private runtime home. Undefined when HOME itself is the store. */
+function configDirHomeEnv(harness, runtimeHome, agentHome) {
+	const contract = NATIVE_SESSION_CONTRACTS[harness];
+	const stores = Object.entries(contract?.storeEnv ?? {}).filter(([name]) => !name.startsWith("--"));
+	if (stores.length === 0 || HOME_KEYED_RUNTIMES.has(harness)) return void 0;
+	const home = runtimeHome.replace(/\/+$/u, "");
+	return {
+		HOME: agentHome,
+		XDG_CONFIG_HOME: `${home}/.config`,
+		XDG_CACHE_HOME: `${home}/.cache`,
+		XDG_DATA_HOME: `${home}/.local/share`,
+		XDG_STATE_HOME: `${home}/.local/state`,
+		...Object.fromEntries(stores.map(([name, relative]) => [name, `${home}/${relative}`]))
+	};
+}
+/** No capture claims these sessions. They stay until their product surfaces drop them. */
+const HARNESS_SESSION_UNSUPPORTED = { cursor: HARNESSES["cursor"].session.defect.reason };
+//#endregion
+export { HARNESS_SESSION_UNSUPPORTED, NATIVE_SESSION_CONTRACTS, configDirHomeEnv };
+
+//# sourceMappingURL=native-session-contracts.mjs.map

package/dist/servable-models.d.mts

@@ -0,0 +1,103 @@
+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 (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.
+ */
+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