@happyvertical/smrt-inference 0.0.0-stage → 0.60.16

package/agents/settings.md

@@ -0,0 +1,107 @@
+# Settings UI and binding storage (#4754)
+
+Consumer guide: [docs/content/inference-settings.md](../../../docs/content/inference-settings.md).
+
+- **Storage split, enforced by API shape.** Keys: the panel emits
+  `onSaveKey({ provider, key, preset?, baseUrl? })` (the endpoint shown when
+  the key was typed; the key input remounts on a provider or base URL
+  change), the host binds it with `bindInferenceKey()` and stores it once,
+  as the #4756 `inference.provider-config` secret, through the user
+  resolver's `write()` (`inferenceProviderConfigFromKey()` converts the
+  record and re-checks the bound origin), and the panel only ever gets
+  `keySet` back. User choices (mode `byo | local | hosted |
+  off`, provider, base URL, model, default tier): smrt-preferences kind
+  `inference` (`inferencePreferenceKind`, permissions `inference.customize`
+  / `inference.personalize`; the host registers both, smrt-preferences is
+  not a dependency). App/tenant bindings: `_smrt_inference_overrides`.
+- **Key rule** (`src/settings/keys.ts`, ported from the planner's BYO
+  screen): a key is bound when saved to the origin of its endpoint
+  (explicit base URL, else preset, else `inferenceProbeUrl()`'s provider
+  default, a provider id that is a preset id counting as that preset;
+  https only, plain http for loopback; gateways such as
+  `litellm`/`bifrost` need a base URL) and `inferenceKeyFor()` releases it
+  only for a URL on that origin. `testConnection()` reads no environment key
+  and never probes another origin with a stored key; details pass
+  `redactInferenceSecret()`. Binding rows, preference payloads and tested
+  candidates refuse credential-shaped members (`findKeyMember()`; `key` is
+  allowed because #4753 fusions carry one).
+- **Override table**: one row per `(binding, context)`, binding
+  `tier:<tier> | default-tier | alias:<name> | fusion:<name>`, `context`
+  `__app__` or the tenant id (the prompts pattern), `target` JSON,
+  `tenant_allow_list` JSON on app rows. Generated surfaces are closed; ships
+  through `smrt db:migrate` (`override-migration.test.ts`). A tier target is
+  exactly a model `{ provider?, model }`, an alias `{ alias }` or a fusion
+  `{ kind: 'fusion', fusion }`: no endpoint, key or inline chain (those go
+  in an alias). Layers, low to high: code default (configured client),
+  `inference` config, app row, tenant row; each target replaced whole.
+- **Tenant allow-list**: a tenant writes only `tier:*` and `default-tier`,
+  only to a reference (`model:<provider>/<model>`, `alias:<n>`,
+  `fusion:<n>`, `tier:<t>`; trailing `*` and `*` match) on the app row's
+  list (no list allows nothing), and only when the
+  `tenantTargetPolicy` hook returns `true`; this hook is where #4667 caps
+  the maximum hosted tier. Both are re-checked on every layered read, so a
+  narrowed list or policy disables existing tenant rows (`tenantBlocked`).
+  Aliases and fusions are app-scope only (a tenant definition could
+  redefine an allow-listed name).
+- **`InferenceSettingsService`** mirrors `PromptSettingsService`:
+  `listInferenceSettings()` returns one row per tier with the effective
+  target, each scope's raw value and both revert previews computed
+  separately (`appRevertTarget` = config, never the app row;
+  `inheritedTarget` = config + app row), plus `getDefaultTierSetting()`,
+  `listInferenceAliases()`, `listInferenceFusions()` (registry: the
+  `registryFusions` option, default #4753's `defineFusion()` registry;
+  config `inference.fusions`; editable app rows), each entry with
+  `shadows` (lower sources it replaces by name) and `issues` (what would make
+  the executor refuse it, prompt keys included), the executor's precedence
+  (#4800). `setFusion()` refuses credential members, then a definition that
+  adds a structural issue. Writes go through `InferenceOverrideService`
+  (authorizer first, fails closed; without `authorize` the service is
+  read-only) and refuse a value that adds a config issue to the layer it
+  lands in; removing an app alias or fusion that any row (every tenant) or
+  config still names is refused (`InferenceBindingInUseError`, tenant rows
+  only counted, checked after the authorizer allowed the write) unless
+  config or the registry keeps defining it. Every config-backed value a row method
+  returns passes `stripKeyMembers()` (config may carry literal keys);
+  `getEffectiveConfig()` is server-side only. `testConnection()`, `testCandidate()` and `doctor()` reuse
+  `./node`; `testCandidate()` reads a key variable only for a candidate
+  already in the effective config (an unsaved one is probed keyless);
+  `usage()` is `reportAiUsage()` by model (default), tier, prompt, fusion,
+  template, with `transcripts: true` for per-bucket counts (#4781).
+- **Transcript setting** (#4781, `src/settings/transcripts.ts`): binding
+  `transcripts`, app row only (service and model refuse a tenant row),
+  value `{ enabled?, sample?, maxBytes? }` checked by core's
+  `assertInferenceTranscriptsConfig()`. `setTranscriptSettings()` writes it
+  through the authorizer and installs it as core's
+  `setAiTranscriptAppSettings()` layer (config < app row < env); the
+  override resolver re-applies the app rows on every resolve (rows cached
+  for `ttlMs`), `loadInferenceTranscriptSettings()` is the worker startup
+  hook. `getTranscriptSettings()` adds the revert preview, the env override
+  (detected by forcing both values through the layer) and the sweep's
+  retention days, read-only (the sweep runs with its caller's policy).
+- **`createInferenceOverrideResolver({ db, base })`** applies stored
+  bindings at call time and defers unbound tiers to `base` or config; an
+  app-only alias is returned as its inline candidate chain because the
+  executor reads only the process config. Rows (not layers) are cached per
+  tenant for `ttlMs` (30 s) and invalidated by any write in the process; the
+  allow-list and policy are re-applied on every call, and only the requested
+  tier's chain is validated, so one dangling reference fails one tier.
+  Compose it as the per-user resolver's `fallback` (see AGENTS.md,
+  "Resolver composition"). Its `lookupFusion()` (#4800) answers core's
+  executor lookup from app rows only (read with no tenant, so a tenant row
+  never defines a fusion), validated against config + app rows with every
+  seat prompt key (`InferenceConfigError`, paths `fusion:<name>…`), app-only
+  seat aliases inlined like tier aliases; an app row that exists but cannot
+  be read fails `fusion-invalid` (never its value) rather than deferring (the
+  list shows it as the app winner with that issue); no app row defers to
+  `base`, then config. An app row shadows a config fusion of the same name.
+- **Panel** (`src/svelte`): built like `PromptSettingsPanel` (presentational,
+  `svelte` optional peer, prune script, two-project Vitest, `svelte-check`,
+  named `$props()` interfaces, types free of core). The default view is the
+  whole screen for one provider; Advanced (tier ladder, `auto` tier,
+  aliases, fusions) is not rendered until opened. The key input is its own
+  form, never in state, cleared on submit. Tenant scope disables targets
+  off the allow-list (display only) and makes aliases/fusions read-only.
+  Rows remount on `contextKey`. The transcript section is read-only unless
+  `appEditable` and `onSaveTranscripts` are both passed; the Usage tab
+  links counts through the host's `transcriptHref` and renders no
+  transcript content (#4781).

package/dist/__smrt-register__.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=__smrt-register__.d.ts.map

package/dist/__smrt-register__.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"__smrt-register__.d.ts","sourceRoot":"","sources":["../src/__smrt-register__.ts"],"names":[],"mappings":""}

package/dist/chunks/InferenceOverrideCollection-Dat4TrK5.js

@@ -0,0 +1,423 @@
+import { INFERENCE_TIERS, ObjectRegistry, SmrtCollection, SmrtObject, assertInferenceTranscriptsConfig, field, inferenceTargetKind, isInferenceTier, smrt } from "@happyvertical/smrt-core";
+//#region src/__smrt-register__.ts
+ObjectRegistry.registerPackageManifest(JSON.parse(`{"version":"1.0.0","timestamp":0,"packageName":"@happyvertical/smrt-inference","packageVersion":"0.60.16","objects":{"@happyvertical/smrt-inference:InferenceOverride":{"name":"inferenceoverride","className":"InferenceOverride","qualifiedName":"@happyvertical/smrt-inference:InferenceOverride","collection":"inferenceoverrides","filePath":"/home/runner/work/smrt/smrt/packages/inference/src/models/InferenceOverride.ts","packageName":"@happyvertical/smrt-inference","fields":{"binding":{"type":"text","required":true,"default":"","_meta":{"required":true}},"tenantId":{"type":"text","required":false,"_meta":{"sqlType":"UUID","nullable":true}},"target":{"type":"text","required":false,"_meta":{"nullable":true}},"tenantAllowList":{"type":"text","required":false,"_meta":{"nullable":true}}},"methods":{"getValue":{"name":"getValue","async":false,"parameters":[],"returnType":"unknown","isStatic":false,"isPublic":true},"getTenantAllowList":{"name":"getTenantAllowList","async":false,"parameters":[],"returnType":"string[] | null","isStatic":false,"isPublic":true},"save":{"name":"save","async":true,"parameters":[{"name":"options","type":"SmrtSaveOptions","optional":true}],"returnType":"Promise<this>","isStatic":false,"isPublic":true},"delete":{"name":"delete","async":true,"parameters":[],"returnType":"Promise<void>","isStatic":false,"isPublic":true}},"decoratorConfig":{"tableName":"_smrt_inference_overrides","conflictColumns":["binding","context"],"api":false,"cli":false,"mcp":false,"indexes":[{"name":"idx_smrt_inference_overrides_tenant","columns":["tenantId","binding"]}]},"extends":"SmrtObject","exportName":"InferenceOverride","collectionExportName":"InferenceOverrideCollection","validationRules":[{"field":"binding","rule":"required","fieldType":"text"}],"schema":{"tableName":"_smrt_inference_overrides","ddl":"CREATE TABLE IF NOT EXISTS \\"_smrt_inference_overrides\\" (\\n  \\"_sync_origin_device_id\\" TEXT,\\n  \\"_sync_revision\\" INTEGER,\\n  \\"id\\" UUID PRIMARY KEY NOT NULL,\\n  \\"slug\\" TEXT NOT NULL,\\n  \\"context\\" TEXT NOT NULL DEFAULT '',\\n  \\"created_at\\" TIMESTAMP NOT NULL DEFAULT current_timestamp,\\n  \\"updated_at\\" TIMESTAMP NOT NULL DEFAULT current_timestamp,\\n  \\"binding\\" TEXT NOT NULL DEFAULT '',\\n  \\"tenant_id\\" UUID,\\n  \\"target\\" TEXT,\\n  \\"tenant_allow_list\\" TEXT\\n);","columns":{"_sync_origin_device_id":{"type":"TEXT"},"_sync_revision":{"type":"INTEGER"},"id":{"type":"UUID","primaryKey":true,"referenceKind":"id","notNull":true},"slug":{"type":"TEXT","notNull":true},"context":{"type":"TEXT","notNull":true,"default":""},"created_at":{"type":"TIMESTAMP","notNull":true,"default":"current_timestamp"},"updated_at":{"type":"TIMESTAMP","notNull":true,"default":"current_timestamp"},"binding":{"type":"TEXT","notNull":true,"unique":false,"default":""},"tenant_id":{"type":"UUID","notNull":false,"unique":false},"target":{"type":"TEXT","notNull":false,"unique":false},"tenant_allow_list":{"type":"TEXT","notNull":false,"unique":false}},"indexes":[{"name":"_smrt_inference_overrides_binding_context_idx","columns":["binding","context"],"unique":true},{"name":"_smrt_inference_overrides_slug_context_idx","columns":["slug","context"]},{"name":"idx_smrt_inference_overrides_tenant","columns":["tenant_id","binding"]},{"name":"_smrt_inference_overrides_created_at_idx","columns":["created_at"]}],"version":"4868b81b"},"importPath":"@happyvertical/smrt-inference/models"},"@happyvertical/smrt-inference:InferenceOverrideCollection":{"name":"inferenceoverridecollection","className":"InferenceOverrideCollection","qualifiedName":"@happyvertical/smrt-inference:InferenceOverrideCollection","collection":"inferenceoverrides","description":"Reads and unauthorized writes of _smrt_inference_overrides.","filePath":"/home/runner/work/smrt/smrt/packages/inference/src/models/InferenceOverrideCollection.ts","packageName":"@happyvertical/smrt-inference","fields":{},"methods":{"getScopeMap":{"name":"getScopeMap","async":true,"parameters":[{"name":"scopeType","type":"InferenceOverrideScopeType","optional":false,"resolvedType":"'app' | 'tenant'"},{"name":"scopeId","type":"string","optional":false}],"returnType":"Promise<Map<string, InferenceOverride>>","isStatic":false,"isPublic":true},"findByScope":{"name":"findByScope","async":true,"parameters":[{"name":"binding","type":"string","optional":false},{"name":"scopeType","type":"InferenceOverrideScopeType","optional":false,"resolvedType":"'app' | 'tenant'"},{"name":"scopeId","type":"string","optional":false}],"returnType":"Promise<InferenceOverride | null>","isStatic":false,"isPublic":true},"setOverride":{"name":"setOverride","async":true,"parameters":[{"name":"binding","type":"string","optional":false},{"name":"scopeType","type":"InferenceOverrideScopeType","optional":false,"resolvedType":"'app' | 'tenant'"},{"name":"scopeId","type":"string","optional":false},{"name":"change","type":"object","optional":false,"memberTypes":["unknown","string[] | null"]}],"returnType":"Promise<InferenceOverride | null>","isStatic":false,"isPublic":true},"removeOverride":{"name":"removeOverride","async":true,"parameters":[{"name":"binding","type":"string","optional":false},{"name":"scopeType","type":"InferenceOverrideScopeType","optional":false,"resolvedType":"'app' | 'tenant'"},{"name":"scopeId","type":"string","optional":false}],"returnType":"Promise<boolean>","isStatic":false,"isPublic":true}},"decoratorConfig":{"tableName":"_smrt_inference_overrides","api":false,"mcp":false,"cli":false},"extends":"SmrtCollection","extendsTypeArg":"InferenceOverride","exportName":"InferenceOverrideCollection","collectionExportName":"InferenceOverrideCollectionCollection","collectionOf":"@happyvertical/smrt-inference:InferenceOverride","inheritedExposure":["api","mcp","cli"],"schema":{"tableName":"_smrt_inference_overrides","ddl":"CREATE TABLE IF NOT EXISTS \\"_smrt_inference_overrides\\" (\\n  \\"_sync_origin_device_id\\" TEXT,\\n  \\"_sync_revision\\" INTEGER,\\n  \\"id\\" UUID PRIMARY KEY NOT NULL,\\n  \\"slug\\" TEXT NOT NULL,\\n  \\"context\\" TEXT NOT NULL DEFAULT '',\\n  \\"created_at\\" TIMESTAMP NOT NULL DEFAULT current_timestamp,\\n  \\"updated_at\\" TIMESTAMP NOT NULL DEFAULT current_timestamp,\\n  \\"binding\\" TEXT NOT NULL DEFAULT '',\\n  \\"tenant_id\\" UUID,\\n  \\"target\\" TEXT,\\n  \\"tenant_allow_list\\" TEXT\\n);","columns":{"_sync_origin_device_id":{"type":"TEXT"},"_sync_revision":{"type":"INTEGER"},"id":{"type":"UUID","primaryKey":true,"referenceKind":"id","notNull":true},"slug":{"type":"TEXT","notNull":true},"context":{"type":"TEXT","notNull":true,"default":""},"created_at":{"type":"TIMESTAMP","notNull":true,"default":"current_timestamp"},"updated_at":{"type":"TIMESTAMP","notNull":true,"default":"current_timestamp"},"binding":{"type":"TEXT","notNull":true,"unique":false,"default":""},"tenant_id":{"type":"UUID","notNull":false,"unique":false},"target":{"type":"TEXT","notNull":false,"unique":false},"tenant_allow_list":{"type":"TEXT","notNull":false,"unique":false}},"indexes":[{"name":"_smrt_inference_overrides_binding_context_idx","columns":["binding","context"],"unique":true},{"name":"_smrt_inference_overrides_slug_context_idx","columns":["slug","context"]},{"name":"idx_smrt_inference_overrides_tenant","columns":["tenant_id","binding"]},{"name":"_smrt_inference_overrides_created_at_idx","columns":["created_at"]}],"version":"4868b81b"},"importPath":"@happyvertical/smrt-inference/models"}},"moduleType":"smrt","smrtDependencies":["@happyvertical/smrt-core","@happyvertical/smrt-prompts","@happyvertical/smrt-secrets","@happyvertical/smrt-tenancy","@happyvertical/smrt-users"],"browser":{"status":"server-only","issues":["#3617","#3624","#3626","#3627"],"via":["@happyvertical/smrt-profiles","@happyvertical/smrt-secrets","@happyvertical/smrt-tenancy","@happyvertical/smrt-users"]},"stampsConstructors":true}`));
+//#endregion
+//#region src/settings/cache.ts
+var GENERATION_KEY = /* @__PURE__ */ Symbol.for("smrt.inference.overrideGeneration");
+function getInferenceOverrideGeneration() {
+	return globalThis[GENERATION_KEY] ?? 0;
+}
+function bumpInferenceOverrideGeneration() {
+	const holder = globalThis;
+	holder[GENERATION_KEY] = (holder[GENERATION_KEY] ?? 0) + 1;
+}
+//#endregion
+//#region src/settings/targets.ts
+var INFERENCE_MODES$1 = [
+	"byo",
+	"local",
+	"hosted",
+	"off"
+];
+var DEFAULT_TIER_BINDING = "default-tier";
+var TRANSCRIPTS_BINDING = "transcripts";
+var INFERENCE_BINDING_NAME_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/i;
+var InferenceBindingValueError = class extends Error {
+	constructor(binding, reason) {
+		super(`Invalid inference binding "${binding}": ${reason}`);
+		this.binding = binding;
+		this.name = "InferenceBindingValueError";
+	}
+	binding;
+	status = 400;
+};
+function parseInferenceBinding(binding) {
+	if (typeof binding !== "string") return null;
+	if (binding === "default-tier") return { kind: "default-tier" };
+	if (binding === "transcripts") return { kind: "transcripts" };
+	const match = /^(tier|alias|fusion):(.+)$/.exec(binding);
+	if (!match) return null;
+	const [, kind, name] = match;
+	if (kind === "tier") return isInferenceTier(name) ? {
+		kind: "tier",
+		name
+	} : null;
+	if (!INFERENCE_BINDING_NAME_PATTERN.test(name)) return null;
+	return {
+		kind,
+		name
+	};
+}
+function tierBinding(tier) {
+	return `tier:${tier}`;
+}
+function isRecord(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function text(value) {
+	return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+var KEY_MEMBERS = /* @__PURE__ */ new Set([
+	"apikey",
+	"api_key",
+	"apikeys",
+	"secret",
+	"token",
+	"password",
+	"authorization",
+	"bearer"
+]);
+function stripKeyMembers(value) {
+	if (Array.isArray(value)) return value.map(stripKeyMembers);
+	if (!isRecord(value)) return value;
+	const out = {};
+	for (const [member, inner] of Object.entries(value)) {
+		if (KEY_MEMBERS.has(member.toLowerCase())) continue;
+		out[member] = stripKeyMembers(inner);
+	}
+	return out;
+}
+function findKeyMember(value, path = "") {
+	if (Array.isArray(value)) {
+		for (const [index, item] of value.entries()) {
+			const found = findKeyMember(item, `${path}[${index}]`);
+			if (found) return found;
+		}
+		return null;
+	}
+	if (!isRecord(value)) return null;
+	for (const [member, inner] of Object.entries(value)) {
+		const here = path ? `${path}.${member}` : member;
+		if (KEY_MEMBERS.has(member.toLowerCase())) return here;
+		const found = findKeyMember(inner, here);
+		if (found) return found;
+	}
+	return null;
+}
+function normalizeTierTarget(binding, value) {
+	if (value === null || value === void 0) return null;
+	if (!isRecord(value)) throw new InferenceBindingValueError(binding, "a tier target is an object");
+	const keyMember = findKeyMember(value);
+	if (keyMember) throw new InferenceBindingValueError(binding, `"${keyMember}" looks like a credential; keys are stored only through smrt-secrets`);
+	const fusion = text(value.fusion);
+	const alias = text(value.alias);
+	const model = text(value.model);
+	const provider = text(value.provider);
+	const kind = value.kind;
+	const allowed = /* @__PURE__ */ new Set([
+		"kind",
+		"fusion",
+		"alias",
+		"model",
+		"provider"
+	]);
+	const extra = Object.keys(value).filter((member) => !allowed.has(member));
+	if (extra.length > 0) throw new InferenceBindingValueError(binding, `unsupported member(s) ${extra.join(", ")} (endpoints and inline candidates belong in an alias)`);
+	if ([
+		fusion,
+		alias,
+		model
+	].filter(Boolean).length !== 1) throw new InferenceBindingValueError(binding, "a tier target is exactly one of { model, provider? }, { alias } or { kind: \"fusion\", fusion }");
+	if (fusion) {
+		if (kind !== void 0 && kind !== "fusion") throw new InferenceBindingValueError(binding, "fusion kind mismatch");
+		if (!INFERENCE_BINDING_NAME_PATTERN.test(fusion)) throw new InferenceBindingValueError(binding, "invalid fusion name");
+		return {
+			kind: "fusion",
+			fusion
+		};
+	}
+	if (alias) {
+		if (kind !== void 0 && kind !== "alias") throw new InferenceBindingValueError(binding, "alias kind mismatch");
+		if (!INFERENCE_BINDING_NAME_PATTERN.test(alias)) throw new InferenceBindingValueError(binding, "invalid alias name");
+		return { alias };
+	}
+	if (kind !== void 0 && kind !== "single") throw new InferenceBindingValueError(binding, "model kind mismatch");
+	return provider ? {
+		provider,
+		model
+	} : { model };
+}
+function normalizeAliasDefinition(binding, value) {
+	if (value === null || value === void 0) return null;
+	if (!isRecord(value) || !Array.isArray(value.candidates)) throw new InferenceBindingValueError(binding, "an alias is { candidates: [...], description? }");
+	const keyMember = findKeyMember(value);
+	if (keyMember) throw new InferenceBindingValueError(binding, `"${keyMember}" looks like a credential; keys are stored only through smrt-secrets`);
+	if (value.candidates.length === 0) throw new InferenceBindingValueError(binding, "an alias needs candidates");
+	const allowed = /* @__PURE__ */ new Set([
+		"provider",
+		"model",
+		"baseUrl",
+		"apiKeyEnv",
+		"preset",
+		"alias",
+		"params"
+	]);
+	const candidates = value.candidates.map((candidate, index) => {
+		if (!isRecord(candidate)) throw new InferenceBindingValueError(binding, `candidates[${index}] must be an object`);
+		const extra = Object.keys(candidate).filter((member) => !allowed.has(member));
+		if (extra.length > 0) throw new InferenceBindingValueError(binding, `candidates[${index}] has unsupported member(s) ${extra.join(", ")}`);
+		const out = {};
+		for (const member of allowed) {
+			if (member === "params") continue;
+			const inner = text(candidate[member]);
+			if (inner) out[member] = inner;
+		}
+		if (candidate.params !== void 0) {
+			if (!isRecord(candidate.params)) throw new InferenceBindingValueError(binding, `candidates[${index}].params must be an object`);
+			out.params = { ...candidate.params };
+		}
+		return out;
+	});
+	const description = text(value.description);
+	return description ? {
+		candidates,
+		description
+	} : { candidates };
+}
+function normalizeFusionDefinition(binding, value) {
+	if (value === null || value === void 0) return null;
+	if (!isRecord(value)) throw new InferenceBindingValueError(binding, "a fusion is a JSON object");
+	const keyMember = findKeyMember(value);
+	if (keyMember) throw new InferenceBindingValueError(binding, `"${keyMember}" looks like a credential; keys are stored only through smrt-secrets`);
+	return JSON.parse(JSON.stringify(value));
+}
+function normalizeDefaultTier(binding, value) {
+	if (value === null || value === void 0) return null;
+	const tier = isRecord(value) ? value.tier : value;
+	if (!isInferenceTier(tier)) throw new InferenceBindingValueError(binding, `the default tier must be one of ${INFERENCE_TIERS.join(", ")}`);
+	return tier;
+}
+var TRANSCRIPT_SETTING_MEMBERS = /* @__PURE__ */ new Set([
+	"enabled",
+	"sample",
+	"maxBytes"
+]);
+function normalizeTranscriptSettings(binding, value) {
+	if (value === null || value === void 0) return null;
+	if (!isRecord(value)) throw new InferenceBindingValueError(binding, "the transcript setting must be an object");
+	const extra = Object.keys(value).filter((member) => !TRANSCRIPT_SETTING_MEMBERS.has(member));
+	if (extra.length > 0) throw new InferenceBindingValueError(binding, `the transcript setting carries enabled, sample and maxBytes only (got ${extra.join(", ")})`);
+	try {
+		assertInferenceTranscriptsConfig(value);
+	} catch (error) {
+		throw new InferenceBindingValueError(binding, error instanceof Error ? error.message : String(error));
+	}
+	const out = {};
+	if (value.enabled !== void 0) out.enabled = value.enabled;
+	if (value.sample !== void 0) out.sample = value.sample;
+	if (value.maxBytes !== void 0) out.maxBytes = value.maxBytes;
+	return Object.keys(out).length > 0 ? out : null;
+}
+function inferenceTargetRef(target) {
+	const kind = inferenceTargetKind(target);
+	const record = target;
+	if (kind === "fusion") return `fusion:${record.fusion ?? ""}`;
+	if (kind === "alias") return `alias:${target.alias ?? ""}`;
+	if (kind === "candidates") return "candidates";
+	return `model:${target.provider ?? "default"}/${target.model ?? "default"}`;
+}
+function matchesAllowPattern(ref, pattern) {
+	if (pattern === "*") return true;
+	if (pattern.endsWith("*")) return ref.startsWith(pattern.slice(0, -1));
+	return ref === pattern;
+}
+function isAllowedByList(ref, allowList) {
+	return (allowList ?? []).some((pattern) => matchesAllowPattern(ref, pattern));
+}
+function normalizeAllowList(binding, value) {
+	if (value === null || value === void 0) return null;
+	if (!Array.isArray(value)) throw new InferenceBindingValueError(binding, "an allow-list is an array of references");
+	const out = [];
+	for (const entry of value) {
+		if (typeof entry !== "string" || !/^(\*|(model|alias|fusion|tier):[A-Za-z0-9._/:*-]{1,160})$/.test(entry)) throw new InferenceBindingValueError(binding, `invalid allow-list entry ${JSON.stringify(entry)}`);
+		if (!out.includes(entry)) out.push(entry);
+	}
+	return out;
+}
+function describeInferenceTarget(target) {
+	if (!target || Object.keys(target).length === 0) return "Same as default (configured client)";
+	const kind = inferenceTargetKind(target);
+	const record = target;
+	if (kind === "fusion") return `Fusion ${record.fusion ?? "?"}`;
+	if (kind === "alias") return `Alias ${target.alias ?? "?"}`;
+	if (kind === "candidates") return `${target.candidates?.length ?? 0} inline candidate(s)`;
+	return `${target.provider ?? "default"}/${target.model ?? "default model"}`;
+}
+//#endregion
+//#region src/models/InferenceOverride.ts
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value
+}) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp(target, key, result);
+	return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var APP_INFERENCE_SCOPE_ID = "__app__";
+function parseJson(binding, raw, what) {
+	if (raw === null) return null;
+	try {
+		return JSON.parse(raw);
+	} catch {
+		throw new InferenceBindingValueError(binding, `${what} is not valid JSON`);
+	}
+}
+var InferenceOverride = class extends SmrtObject {
+	binding = "";
+	tenantId = null;
+	target = null;
+	tenantAllowList = null;
+	constructor(options = {}) {
+		super(options);
+		if (options.binding !== void 0) this.binding = options.binding;
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.target !== void 0) this.target = options.target;
+		if (options.tenantAllowList !== void 0) this.tenantAllowList = options.tenantAllowList;
+	}
+	/** The parsed, validated stored value (`null` inherits). */
+	getValue() {
+		return this.normalizedValue();
+	}
+	/** The parsed allow-list (`null` when the row carries none). */
+	getTenantAllowList() {
+		return normalizeAllowList(this.binding, parseJson(this.binding, this.tenantAllowList, "tenantAllowList"));
+	}
+	async save(options) {
+		this.validateOverride();
+		this.context = this.tenantId ?? "__app__";
+		const result = await super.save(options);
+		bumpInferenceOverrideGeneration();
+		return result;
+	}
+	async delete() {
+		await super.delete();
+		bumpInferenceOverrideGeneration();
+	}
+	normalizedValue() {
+		const parsed = parseInferenceBinding(this.binding);
+		if (!parsed) throw new InferenceBindingValueError(String(this.binding), "unknown binding id");
+		const raw = parseJson(this.binding, this.target, "target");
+		switch (parsed.kind) {
+			case "tier": return normalizeTierTarget(this.binding, raw);
+			case "default-tier": return normalizeDefaultTier(this.binding, raw);
+			case "transcripts": return normalizeTranscriptSettings(this.binding, raw);
+			case "alias": return normalizeAliasDefinition(this.binding, raw);
+			case "fusion": return normalizeFusionDefinition(this.binding, raw);
+		}
+	}
+	validateOverride() {
+		const parsed = parseInferenceBinding(this.binding);
+		if (!parsed) throw new InferenceBindingValueError(String(this.binding), "unknown binding id");
+		if (this.tenantId !== null) {
+			if (typeof this.tenantId !== "string" || !this.tenantId.trim() || this.tenantId !== this.tenantId.trim() || this.tenantId === "__app__") throw new InferenceBindingValueError(this.binding, "invalid tenant id");
+			if (parsed.kind === "alias" || parsed.kind === "fusion") throw new InferenceBindingValueError(this.binding, "aliases and fusions are defined at the app scope only");
+			if (parsed.kind === "transcripts") throw new InferenceBindingValueError(this.binding, "the transcript setting is app scope only");
+			if (this.tenantAllowList !== null) throw new InferenceBindingValueError(this.binding, "the tenant allow-list lives on the app row");
+		}
+		if (this.tenantAllowList !== null && parsed.kind !== "tier" && parsed.kind !== "default-tier") throw new InferenceBindingValueError(this.binding, "only tier and default-tier bindings carry a tenant allow-list");
+		const value = this.normalizedValue();
+		this.target = value === null ? null : JSON.stringify(value);
+		const allowList = this.getTenantAllowList();
+		this.tenantAllowList = allowList === null ? null : JSON.stringify(allowList);
+	}
+};
+__publicField(InferenceOverride, "__smrtPackage__", "@happyvertical/smrt-inference");
+__decorateClass([field({ required: true })], InferenceOverride.prototype, "binding", 2);
+__decorateClass([field({
+	sqlType: "UUID",
+	nullable: true
+})], InferenceOverride.prototype, "tenantId", 2);
+__decorateClass([field({
+	type: "text",
+	nullable: true
+})], InferenceOverride.prototype, "target", 2);
+__decorateClass([field({
+	type: "text",
+	nullable: true
+})], InferenceOverride.prototype, "tenantAllowList", 2);
+InferenceOverride = __decorateClass([smrt({
+	tableName: "_smrt_inference_overrides",
+	conflictColumns: ["binding", "context"],
+	api: false,
+	cli: false,
+	mcp: false,
+	indexes: [{
+		name: "idx_smrt_inference_overrides_tenant",
+		columns: ["tenantId", "binding"]
+	}]
+})], InferenceOverride);
+//#endregion
+//#region src/models/InferenceOverrideCollection.ts
+var InferenceOverrideCollection = class extends SmrtCollection {
+	static _itemClass = InferenceOverride;
+	/**
+	* Every row of one scope, keyed by binding id: one bounded read. An
+	* enumeration read: build the collection without list bounds (the
+	* settings service does) so a host-wide `maxListLimit` cannot drop a row.
+	*/
+	async getScopeMap(scopeType, scopeId) {
+		const tenantId = scopeType === "app" ? null : scopeId;
+		const rows = await this.list({ where: { tenantId } });
+		const result = /* @__PURE__ */ new Map();
+		for (const row of rows) result.set(row.binding, row);
+		return result;
+	}
+	/** The row for one binding at one scope. */
+	async findByScope(binding, scopeType, scopeId) {
+		const tenantId = scopeType === "app" ? null : scopeId;
+		return (await this.list({
+			where: {
+				binding,
+				tenantId
+			},
+			limit: 1
+		}))[0] ?? null;
+	}
+	/**
+	* Set the stored value (and, for app rows, optionally the tenant
+	* allow-list) of one binding at one scope, creating the row when needed.
+	* `undefined` leaves a column untouched; `null` clears it. A row left with
+	* neither a value nor an allow-list is deleted.
+	*/
+	async setOverride(binding, scopeType, scopeId, change) {
+		const existing = await this.findByScope(binding, scopeType, scopeId);
+		const target = change.target === void 0 ? existing?.target ?? null : change.target === null ? null : JSON.stringify(change.target);
+		const tenantAllowList = change.tenantAllowList === void 0 ? existing?.tenantAllowList ?? null : change.tenantAllowList === null ? null : JSON.stringify(change.tenantAllowList);
+		if (target === null && tenantAllowList === null) {
+			if (existing) await existing.delete();
+			return null;
+		}
+		if (existing) {
+			existing.target = target;
+			existing.tenantAllowList = tenantAllowList;
+			await existing.save();
+			return existing;
+		}
+		const created = await this.create({
+			binding,
+			tenantId: scopeType === "app" ? null : scopeId,
+			target,
+			tenantAllowList
+		});
+		await created.save();
+		return created;
+	}
+	/** Delete the row for one binding at one scope, if any. */
+	async removeOverride(binding, scopeType, scopeId) {
+		const existing = await this.findByScope(binding, scopeType, scopeId);
+		if (!existing) return false;
+		await existing.delete();
+		return true;
+	}
+};
+//#endregion
+export { getInferenceOverrideGeneration as C, tierBinding as S, normalizeFusionDefinition as _, INFERENCE_BINDING_NAME_PATTERN as a, parseInferenceBinding as b, TRANSCRIPTS_BINDING as c, inferenceTargetRef as d, isAllowedByList as f, normalizeDefaultTier as g, normalizeAllowList as h, DEFAULT_TIER_BINDING as i, describeInferenceTarget as l, normalizeAliasDefinition as m, APP_INFERENCE_SCOPE_ID as n, INFERENCE_MODES$1 as o, matchesAllowPattern as p, InferenceOverride as r, InferenceBindingValueError as s, InferenceOverrideCollection as t, findKeyMember as u, normalizeTierTarget as v, stripKeyMembers as x, normalizeTranscriptSettings as y };
+
+//# sourceMappingURL=InferenceOverrideCollection-Dat4TrK5.js.map