@happyvertical/smrt-inference 0.0.0-stage → 0.60.16

package/dist/executor.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The chain executor (#4752): runs `alias` and `candidates` tier targets.
+ *
+ * Per call it expands the resolved target into ordered candidates and tries
+ * them in turn. A failure is classified (`classify.ts`); `transient` retries
+ * the same candidate once after a jittered delay, every class then advances.
+ * When a tier's chain is spent and `inference.degrade !== false`, the walk
+ * moves down the ladder (never up), stopping at `minimumTier`. Each move is
+ * a substitution `{ from, to, reason }` carried in the answering call's
+ * `substitutions` usage tag with `tierResolved` set to the tier that
+ * answered; a call that never answered records one zero-token row through
+ * core's usage pipeline and throws {@link InferenceExhaustedError}.
+ *
+ * Text already streamed to the caller is never extended by another
+ * candidate: a candidate that emitted text and then failed ends the walk
+ * with a `partial` substitution (the caller gets the error unless
+ * `allowPartial`).
+ *
+ * Before calling a candidate the walk checks its capabilities (#4758,
+ * `context.capabilitiesFor()`) against the request: JSON mode for a
+ * `responseFormat`, tool calling for `tools`. A mismatch the caller permits
+ * a fallback for (`capabilityFallback`) runs the candidate without the
+ * feature, tagged `capabilityFallback`; any other mismatch is a
+ * `missing-capability` substitution and the walk advances without a call.
+ *
+ * The executor imports no SDK: it drives the clients core builds through
+ * `context.clientFor()`, so tests run it with fake clients.
+ */
+import { type InferenceExecutionContext, type InferenceModelClient } from '@happyvertical/smrt-core';
+/** Test seams for the executor; production uses the defaults. */
+export interface ChainExecutorOptions {
+    /** Delay before the one transient retry. Default 200–500 ms, jittered. */
+    retryDelayMs?: () => number;
+    /** Sleep implementation. */
+    sleep?: (ms: number) => Promise<void>;
+    /** Clock for the failure row's duration. */
+    now?: () => number;
+}
+/**
+ * A client whose calls walk the chain in `context.resolution`. `message`,
+ * `chat`, `complete` and `stream` walk; `embed` uses the first candidate
+ * that can run.
+ */
+export declare function createChainClient(context: InferenceExecutionContext, options?: ChainExecutorOptions): InferenceModelClient;
+//# sourceMappingURL=executor.d.ts.map

package/dist/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../src/executor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,EAKL,KAAK,yBAAyB,EAC9B,KAAK,oBAAoB,EAI1B,MAAM,0BAA0B,CAAC;AAelC,iEAAiE;AACjE,MAAM,WAAW,oBAAoB;IACnC,0EAA0E;IAC1E,YAAY,CAAC,EAAE,MAAM,MAAM,CAAC;IAC5B,4BAA4B;IAC5B,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,4CAA4C;IAC5C,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAggBD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,yBAAyB,EAClC,OAAO,GAAE,oBAAyB,GACjC,oBAAoB,CAmFtB"}

package/dist/fusion-store.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Process registry for code-defined fusions (#4753), on `globalThis` so it
+ * survives HMR and duplicate package copies like core's registries. Storage
+ * only: `defineFusion()` (fusion.ts) validates before it stores.
+ */
+import type { InferenceConfig, InferenceFusionDefinition } from '@happyvertical/smrt-core';
+/** The registry map (created on first use). */
+export declare function fusionStore(): Map<string, InferenceFusionDefinition>;
+/**
+ * The definition a fusion key runs: `inference.fusions.<key>` from config
+ * when present (the app's layer wins), else the `defineFusion()` one.
+ */
+export declare function lookupFusion(key: string, config: InferenceConfig | undefined): InferenceFusionDefinition | undefined;
+/** True when the smrt-prompts process registry holds `key`. */
+export declare function isPromptRegistered(key: string): boolean;
+//# sourceMappingURL=fusion-store.d.ts.map

package/dist/fusion-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fusion-store.d.ts","sourceRoot":"","sources":["../src/fusion-store.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EACV,eAAe,EACf,yBAAyB,EAC1B,MAAM,0BAA0B,CAAC;AAQlC,+CAA+C;AAC/C,wBAAgB,WAAW,IAAI,GAAG,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAIpE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,eAAe,GAAG,SAAS,GAClC,yBAAyB,GAAG,SAAS,CAIvC;AAED,+DAA+D;AAC/D,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAIvD"}

package/dist/fusion.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Consumer-defined fusions (#4753): the interpreter for `{ fusion: '<key>' }`
+ * tier targets. SMRT ships the interpreter and the vocabulary, never a
+ * fusion: modes are code, fusions are config.
+ *
+ * Each seat is a registered prompt key (its resolved template is the seat's
+ * instructions) run on a target through the chain executor
+ * ({@link createChainClient}), so alias chains, classified fallback and the
+ * ladder apply per seat, and every seat's usage row comes from core's usage
+ * pipeline tagged `runId`, `fusionKey` and `seat`. The run itself is one
+ * `_smrt_ai_runs` row through `context.recordRun()`.
+ *
+ * Model calls per mode are fixed: `single` 1, `pair` 3, `handoff` 2. A gate
+ * adds one typed-decision call and can only remove the remaining stage
+ * (recorded `skipped`); a seat's fallback candidates are substitutions of
+ * that seat, recorded in its tags, not extra seats.
+ *
+ * Like the executor, this module imports no SDK: tests drive it with fake
+ * clients through `context.clientFor()`.
+ */
+import { type InferenceCallOptions, type InferenceExecutionContext, type InferenceExecutor, type InferenceFusionDefinition, type InferenceModelClient, type InferenceRunStatus } from '@happyvertical/smrt-core';
+import { type ChainExecutorOptions } from './executor.js';
+import type { InferenceSubstitution } from './types.js';
+/** Input to {@link defineFusion}: a definition plus its key. */
+export interface DefineFusionInput extends InferenceFusionDefinition {
+    key: string;
+}
+/**
+ * Register a fusion in the process registry. Throws
+ * {@link InferenceConfigError} naming every offender by path
+ * (`fusions.<key>...`), including a seat whose prompt key no
+ * `definePrompt()` registered (define prompts first). Alias references are
+ * checked when the fusion runs, against the config of that call. Same
+ * definition again is a no-op; a different one under the same key throws.
+ * `inference.fusions.<key>` in app config wins over a registered fusion.
+ */
+export declare function defineFusion(input: DefineFusionInput): InferenceFusionDefinition;
+/** The registered (code-defined) fusion for `key`, if any. */
+export declare function getFusion(key: string): InferenceFusionDefinition | undefined;
+/** Registered fusion keys. */
+export declare function listFusions(): string[];
+/** Remove every registered fusion (tests). */
+export declare function clearFusions(): void;
+/** A seat's resolved instructions. */
+export interface FusionSeatPrompt {
+    /** The rendered template, sent as the seat's system message. */
+    instructions: string;
+    /** `promptKey`, `promptLayer`, `templateHash` (#4751). */
+    usageTags?: Record<string, string>;
+    /** Prompt-level defaults (`temperature`, `maxTokens`); the seat wins. */
+    params?: Record<string, unknown>;
+}
+/** Resolves a seat's prompt key; the default uses smrt-prompts. */
+export type FusionPromptResolver = (key: string, options: {
+    tenantId?: string | null;
+    db?: unknown;
+}) => Promise<FusionSeatPrompt>;
+/**
+ * Replace the seat prompt resolver (tests, or hosts that bundle without
+ * `@happyvertical/smrt-prompts` resolvable at runtime). `undefined` restores
+ * the default.
+ */
+export declare function setFusionPromptResolver(resolver: FusionPromptResolver | undefined): void;
+/** Token totals observed for one seat. */
+export interface FusionSeatUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    /** Sum of recorded estimates; absent when no event carried one. */
+    estimatedCost?: number;
+}
+/** How one seat went. */
+export type FusionSeatStatus = 'ok' | 'failed' | 'skipped' | 'not-run';
+/** One seat of a {@link FusionRunResult}. */
+export interface FusionSeatResult {
+    /** Persona: the seat name (default the prompt key). */
+    name: string;
+    prompt: string;
+    status: FusionSeatStatus;
+    /** Target label: `tier:<tier>`, `alias:<name>`, `candidates`, `provider/model`. */
+    target: string;
+    /** The candidate that answered (`provider/model`, `default`, ...). */
+    model?: string;
+    /** The seat's text (text seats, and JSON seats that parsed). */
+    text?: string;
+    /** A JSON seat's parsed value. */
+    json?: unknown;
+    /**
+     * A JSON seat whose text did not parse keeps the text here (never
+     * dropped), with the parse error in `parseError`.
+     */
+    raw?: string;
+    parseError?: string;
+    /** Why a seat died: failure class (or `unclassified`) and message. */
+    failure?: {
+        reason: string;
+        message: string;
+        code?: string;
+    };
+    substitutions?: InferenceSubstitution[];
+    usage?: FusionSeatUsage;
+    durationMs?: number;
+}
+/** The decision gate's verdict. */
+export interface FusionGateResult {
+    /**
+     * `sufficient` skipped the remaining stage; `insufficient` ran it;
+     * `unavailable` (no decision client) and `error` ran it too; `not-run`
+     * when no output existed to judge.
+     */
+    status: 'sufficient' | 'insufficient' | 'unavailable' | 'error' | 'not-run';
+    choice?: string;
+    confidence?: number;
+    /** Decision provider and model. */
+    model?: string;
+    message?: string;
+}
+/** A finished (or failed) fusion run. */
+export interface FusionRunResult {
+    runId: string;
+    fusionKey: string;
+    mode: InferenceFusionDefinition['mode'];
+    status: InferenceRunStatus;
+    /** The answer: the final seat's text (see the mode rules). */
+    text: string;
+    seats: FusionSeatResult[];
+    gate?: FusionGateResult;
+    durationMs: number;
+}
+/**
+ * Per-call options a fusion client reads (and strips) besides the usual
+ * `ai.message()` options, which reach the final seat.
+ */
+export interface FusionCallOptions {
+    /** Receives the structured result (per-seat outputs, `raw` JSON text). */
+    onFusionResult?: (result: FusionRunResult) => void;
+}
+/**
+ * Run a fusion for one input and return the structured result. Throws
+ * {@link InferenceFusionError} (`INFERENCE_FUSION_FAILED`) when every seat
+ * died, with the run recorded as `failed`.
+ */
+export declare function runFusion(context: InferenceExecutionContext, input: string, callerOptions?: InferenceCallOptions, options?: ChainExecutorOptions): Promise<FusionRunResult>;
+/**
+ * The client core receives for a `{ fusion }` target: `message()` runs the
+ * fusion and resolves the final seat's text; `onFusionResult` in the call
+ * options receives the structured result.
+ */
+export declare function createFusionClient(context: InferenceExecutionContext, options?: ChainExecutorOptions): InferenceModelClient;
+/**
+ * The executor registered into core's seam: `alias` / `candidates` chains
+ * and `fusion` targets (#4753), one `kinds` table.
+ */
+export declare function createChainExecutor(options?: ChainExecutorOptions): InferenceExecutor;
+//# sourceMappingURL=fusion.d.ts.map

package/dist/fusion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fusion.d.ts","sourceRoot":"","sources":["../src/fusion.ts"],"names":[],"mappings":"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"}

package/dist/gate.d.ts

@@ -0,0 +1,143 @@
+/**
+ * The hosted inference gate (#4760, epic #4667): Node-only, so it stays off
+ * the browser-safe root entry.
+ *
+ * Core asks the registered `InferenceGate` before every `source: hosted`
+ * call (`byo`, `local` and `app` targets never reach it). This gate, in
+ * order:
+ *
+ * 1. **Kill switch.** `inference.hosted.enabled`
+ *    ({@link HOSTED_INFERENCE_KILL_SWITCH}): a global DISABLE, then the
+ *    tenant's own DISABLE, blocks every hosted call at once, whatever the
+ *    plan or spend. Read uncached on every call, without any model call.
+ *    This is the incident lever
+ *    (`smrt inference:hosted disable [--tenant <id>]`).
+ * 2. **Tenant.** A hosted call with no tenant to bill is blocked.
+ * 3. **Entitlement.** The tenant's entitled plan thresholds through
+ *    smrt-subscriptions' `SubscriptionResolver` (memoized per tenant by the
+ *    evaluator: once per request burst). No entitled subscription blocks
+ *    unless `requireSubscription` is false.
+ * 4. **Spend.** The plan's `ai.hosted.spend_micros` (tenant) and
+ *    `ai.hosted.user_spend_micros` (per user) caps against metered hosted
+ *    spend in each cap's window, read fresh from `_smrt_ai_usage`: block,
+ *    warn (`onWarning`), or allow.
+ *
+ * Any error (a database or resolver outage, missing tables, a malformed
+ * cap) propagates, and core turns it into a fail-closed block (policy
+ * `gate-error`) that counts as no spend.
+ *
+ * The kill-switch store and spend evaluator are structural: smrt-features'
+ * `KillSwitchService` and smrt-subscriptions' `HostedAiSpendEvaluator`
+ * satisfy them. Both packages build with the CLI, which depends on this
+ * one, so this package must not depend on them.
+ */
+import { type InferenceEntitlementDetails, type InferenceGate, type InferenceGateRequest } from '@happyvertical/smrt-core';
+import { type InferencePrincipal } from './resolver.js';
+/**
+ * The hosted-inference kill switch key, stored as smrt-features override
+ * rows and read with kill-switch semantics (smrt-features
+ * `readKillSwitch()`): a global DISABLE, then the tenant's own DISABLE.
+ * Persisted identifier: never rename.
+ */
+export declare const HOSTED_INFERENCE_KILL_SWITCH = "inference.hosted.enabled";
+/** A kill switch's state (smrt-features `KillSwitchState`, structurally). */
+export interface HostedKillSwitchState {
+    key: string;
+    enabled: boolean;
+    disabledBy?: 'global' | 'tenant';
+}
+/** Reads (and optionally writes) kill switches: `KillSwitchService`. */
+export interface HostedKillSwitchStore {
+    read(key: string, options: {
+        tenantId?: string | null;
+    }): Promise<HostedKillSwitchState>;
+    set?(key: string, options: {
+        enabled: boolean;
+        tenantId?: string | null;
+    }): Promise<HostedKillSwitchState>;
+}
+/** One cap evaluation, as smrt-subscriptions' `HostedAiSpendEvaluation`. */
+export interface HostedSpendEvaluation {
+    policy: string;
+    /** Integer micro-dollars. */
+    cap: number;
+    /** Integer micro-dollars. */
+    spend: number;
+    resetsAt: Date | null;
+}
+/** The spend decision, as smrt-subscriptions' `HostedAiSpendDecision`. */
+export interface HostedSpendDecision {
+    state: 'ok' | 'warn' | 'blocked';
+    entitled: boolean;
+    decidedBy: HostedSpendEvaluation | null;
+}
+/** Evaluates hosted spend against the plan: `HostedAiSpendEvaluator`. */
+export interface HostedSpendEvaluator {
+    evaluate(input: {
+        tenantId: string;
+        userId?: string;
+    }): Promise<HostedSpendDecision>;
+    invalidate?(tenantId?: string): void;
+}
+/** A hosted call allowed past a warning threshold. */
+export interface HostedInferenceGateWarning {
+    tenantId: string;
+    userId?: string;
+    details: InferenceEntitlementDetails;
+    request: InferenceGateRequest;
+}
+/** Options for {@link createHostedInferenceGate}. */
+export interface HostedInferenceGateOptions {
+    /** Kill-switch store: `new KillSwitchService({ db })` (smrt-features). */
+    killSwitch: HostedKillSwitchStore;
+    /** Spend: `await HostedAiSpendEvaluator.create({ db })` (smrt-subscriptions). */
+    spend: HostedSpendEvaluator;
+    /**
+     * The acting principal; default the ambient one (tenancy context, then
+     * the users session), the same read the per-user resolver makes.
+     */
+    principal?: () => InferencePrincipal | undefined;
+    /**
+     * Block hosted calls for a tenant with no entitled subscription (default
+     * `true`). Set `false` for apps that give hosted AI to every tenant and
+     * use plans only for caps.
+     */
+    requireSubscription?: boolean;
+    /** Called for a call allowed past a `warn` threshold. Must not throw. */
+    onWarning?: (warning: HostedInferenceGateWarning) => void;
+}
+/** The gate, plus a way to drop memoized plan thresholds. */
+export interface HostedInferenceGate extends InferenceGate {
+    /** Forget memoized plan thresholds (all tenants, or one). */
+    invalidate(tenantId?: string): void;
+}
+/**
+ * Create the hosted inference gate. Register it with
+ * {@link registerHostedInferenceGate}.
+ */
+export declare function createHostedInferenceGate(options: HostedInferenceGateOptions): HostedInferenceGate;
+/**
+ * Register a hosted gate (or build one from options) with core's seam, and
+ * the principal's user as the `userId` usage tag that per-user caps meter.
+ * Returns the gate. To remove it, call core's `setInferenceGate(undefined)`
+ * and `setAiUsageUserResolver(undefined)`.
+ */
+export declare function registerHostedInferenceGate(gateOrOptions: HostedInferenceGate | HostedInferenceGateOptions): HostedInferenceGate;
+/** Read the hosted kill switch (global, then `tenantId`). No model call. */
+export declare function getHostedInferenceSwitch(killSwitch: HostedKillSwitchStore, options?: {
+    tenantId?: string | null;
+}): Promise<HostedKillSwitchState>;
+/**
+ * Turn hosted inference off (`enabled: false`) or back on, globally or for
+ * one tenant: the incident lever. Takes effect on the next hosted call in
+ * every process (the gate reads it uncached). Enabling a tenant does not
+ * lift a global disable. The caller is the authorization: smrt-features'
+ * `KillSwitchService.set()` writes the override rows directly (the CLI
+ * holds database credentials); an admin UI writes through
+ * `FeatureOverrideService` with its authorizer instead.
+ */
+export declare function setHostedInferenceEnabled(killSwitch: HostedKillSwitchStore, options: {
+    enabled: boolean;
+    tenantId?: string | null;
+}): Promise<HostedKillSwitchState>;
+//# sourceMappingURL=gate.d.ts.map

package/dist/gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate.d.ts","sourceRoot":"","sources":["../src/gate.ts"],"names":[],"mappings":"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"}

package/dist/gate.js

@@ -0,0 +1,94 @@
+import { getAmbientInferencePrincipal } from "./resolver.js";
+import { setAiUsageUserResolver, setInferenceGate } from "@happyvertical/smrt-core";
+//#region src/gate.ts
+var HOSTED_INFERENCE_KILL_SWITCH = "inference.hosted.enabled";
+function text(value) {
+	return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function block(details) {
+	return {
+		action: "block",
+		details
+	};
+}
+function spendDetails(decision) {
+	const by = decision.decidedBy;
+	if (!by) return null;
+	return {
+		policy: by.policy,
+		cap: by.cap,
+		spend: by.spend,
+		...by.resetsAt ? { resetsAt: by.resetsAt.toISOString() } : {}
+	};
+}
+function createHostedInferenceGate(options) {
+	const principalOf = options.principal ?? getAmbientInferencePrincipal;
+	const requireSubscription = options.requireSubscription !== false;
+	const { killSwitch, spend } = options;
+	return {
+		async check(request) {
+			const principal = principalOf();
+			const tenantId = text(request.tenantId) ?? text(principal?.tenantId);
+			const state = await killSwitch.read(HOSTED_INFERENCE_KILL_SWITCH, { ...tenantId ? { tenantId } : {} });
+			if (state.enabled !== true) return block({
+				policy: "kill-switch",
+				...state.disabledBy ? { disabledBy: state.disabledBy } : {}
+			});
+			if (!tenantId) return block({ policy: "no-tenant" });
+			const userId = request.userId === null || text(principal?.tenantId)?.toLowerCase() !== tenantId.toLowerCase() ? void 0 : text(principal?.userId);
+			const decision = await spend.evaluate({
+				tenantId,
+				...userId ? { userId } : {}
+			});
+			if (!decision.entitled && requireSubscription) return block({ policy: "subscription" });
+			if (decision.state === "blocked") {
+				const details = spendDetails(decision);
+				if (!details) throw new Error("Hosted spend blocked without a cap.");
+				return block(details);
+			}
+			if (decision.state === "warn") {
+				const details = spendDetails(decision);
+				if (details) {
+					try {
+						options.onWarning?.({
+							tenantId,
+							...userId ? { userId } : {},
+							details,
+							request
+						});
+					} catch {}
+					return {
+						action: "warn",
+						details
+					};
+				}
+			}
+			return { action: "allow" };
+		},
+		invalidate(tenantId) {
+			spend.invalidate?.(tenantId);
+		}
+	};
+}
+function registerHostedInferenceGate(gateOrOptions) {
+	const isGate = typeof gateOrOptions.check === "function";
+	const gate = isGate ? gateOrOptions : createHostedInferenceGate(gateOrOptions);
+	const principalOf = !isGate && gateOrOptions.principal || getAmbientInferencePrincipal;
+	setInferenceGate(gate);
+	setAiUsageUserResolver(() => text(principalOf()?.userId));
+	return gate;
+}
+async function getHostedInferenceSwitch(killSwitch, options = {}) {
+	return killSwitch.read(HOSTED_INFERENCE_KILL_SWITCH, options.tenantId ? { tenantId: options.tenantId } : {});
+}
+async function setHostedInferenceEnabled(killSwitch, options) {
+	if (!killSwitch.set) throw new Error("This kill-switch store is read-only.");
+	return killSwitch.set(HOSTED_INFERENCE_KILL_SWITCH, {
+		enabled: options.enabled,
+		...options.tenantId !== void 0 ? { tenantId: options.tenantId } : {}
+	});
+}
+//#endregion
+export { HOSTED_INFERENCE_KILL_SWITCH, createHostedInferenceGate, getHostedInferenceSwitch, registerHostedInferenceGate, setHostedInferenceEnabled };
+
+//# sourceMappingURL=gate.js.map

package/dist/gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate.js","names":[],"sources":["../src/gate.ts"],"sourcesContent":["/**\n * The hosted inference gate (#4760, epic #4667): Node-only, so it stays off\n * the browser-safe root entry.\n *\n * Core asks the registered `InferenceGate` before every `source: hosted`\n * call (`byo`, `local` and `app` targets never reach it). This gate, in\n * order:\n *\n * 1. **Kill switch.** `inference.hosted.enabled`\n *    ({@link HOSTED_INFERENCE_KILL_SWITCH}): a global DISABLE, then the\n *    tenant's own DISABLE, blocks every hosted call at once, whatever the\n *    plan or spend. Read uncached on every call, without any model call.\n *    This is the incident lever\n *    (`smrt inference:hosted disable [--tenant <id>]`).\n * 2. **Tenant.** A hosted call with no tenant to bill is blocked.\n * 3. **Entitlement.** The tenant's entitled plan thresholds through\n *    smrt-subscriptions' `SubscriptionResolver` (memoized per tenant by the\n *    evaluator: once per request burst). No entitled subscription blocks\n *    unless `requireSubscription` is false.\n * 4. **Spend.** The plan's `ai.hosted.spend_micros` (tenant) and\n *    `ai.hosted.user_spend_micros` (per user) caps against metered hosted\n *    spend in each cap's window, read fresh from `_smrt_ai_usage`: block,\n *    warn (`onWarning`), or allow.\n *\n * Any error (a database or resolver outage, missing tables, a malformed\n * cap) propagates, and core turns it into a fail-closed block (policy\n * `gate-error`) that counts as no spend.\n *\n * The kill-switch store and spend evaluator are structural: smrt-features'\n * `KillSwitchService` and smrt-subscriptions' `HostedAiSpendEvaluator`\n * satisfy them. Both packages build with the CLI, which depends on this\n * one, so this package must not depend on them.\n */\n\nimport {\n  type InferenceEntitlementDetails,\n  type InferenceGate,\n  type InferenceGateDecision,\n  type InferenceGateRequest,\n  setAiUsageUserResolver,\n  setInferenceGate,\n} from '@happyvertical/smrt-core';\nimport {\n  getAmbientInferencePrincipal,\n  type InferencePrincipal,\n} from './resolver.js';\n\n/**\n * The hosted-inference kill switch key, stored as smrt-features override\n * rows and read with kill-switch semantics (smrt-features\n * `readKillSwitch()`): a global DISABLE, then the tenant's own DISABLE.\n * Persisted identifier: never rename.\n */\nexport const HOSTED_INFERENCE_KILL_SWITCH = 'inference.hosted.enabled';\n\n/** A kill switch's state (smrt-features `KillSwitchState`, structurally). */\nexport interface HostedKillSwitchState {\n  key: string;\n  enabled: boolean;\n  disabledBy?: 'global' | 'tenant';\n}\n\n/** Reads (and optionally writes) kill switches: `KillSwitchService`. */\nexport interface HostedKillSwitchStore {\n  read(\n    key: string,\n    options: { tenantId?: string | null },\n  ): Promise<HostedKillSwitchState>;\n  set?(\n    key: string,\n    options: { enabled: boolean; tenantId?: string | null },\n  ): Promise<HostedKillSwitchState>;\n}\n\n/** One cap evaluation, as smrt-subscriptions' `HostedAiSpendEvaluation`. */\nexport interface HostedSpendEvaluation {\n  policy: string;\n  /** Integer micro-dollars. */\n  cap: number;\n  /** Integer micro-dollars. */\n  spend: number;\n  resetsAt: Date | null;\n}\n\n/** The spend decision, as smrt-subscriptions' `HostedAiSpendDecision`. */\nexport interface HostedSpendDecision {\n  state: 'ok' | 'warn' | 'blocked';\n  entitled: boolean;\n  decidedBy: HostedSpendEvaluation | null;\n}\n\n/** Evaluates hosted spend against the plan: `HostedAiSpendEvaluator`. */\nexport interface HostedSpendEvaluator {\n  evaluate(input: {\n    tenantId: string;\n    userId?: string;\n  }): Promise<HostedSpendDecision>;\n  invalidate?(tenantId?: string): void;\n}\n\n/** A hosted call allowed past a warning threshold. */\nexport interface HostedInferenceGateWarning {\n  tenantId: string;\n  userId?: string;\n  details: InferenceEntitlementDetails;\n  request: InferenceGateRequest;\n}\n\n/** Options for {@link createHostedInferenceGate}. */\nexport interface HostedInferenceGateOptions {\n  /** Kill-switch store: `new KillSwitchService({ db })` (smrt-features). */\n  killSwitch: HostedKillSwitchStore;\n  /** Spend: `await HostedAiSpendEvaluator.create({ db })` (smrt-subscriptions). */\n  spend: HostedSpendEvaluator;\n  /**\n   * The acting principal; default the ambient one (tenancy context, then\n   * the users session), the same read the per-user resolver makes.\n   */\n  principal?: () => InferencePrincipal | undefined;\n  /**\n   * Block hosted calls for a tenant with no entitled subscription (default\n   * `true`). Set `false` for apps that give hosted AI to every tenant and\n   * use plans only for caps.\n   */\n  requireSubscription?: boolean;\n  /** Called for a call allowed past a `warn` threshold. Must not throw. */\n  onWarning?: (warning: HostedInferenceGateWarning) => void;\n}\n\n/** The gate, plus a way to drop memoized plan thresholds. */\nexport interface HostedInferenceGate extends InferenceGate {\n  /** Forget memoized plan thresholds (all tenants, or one). */\n  invalidate(tenantId?: string): void;\n}\n\nfunction text(value: unknown): string | undefined {\n  return typeof value === 'string' && value.trim() !== ''\n    ? value.trim()\n    : undefined;\n}\n\nfunction block(details: InferenceEntitlementDetails): InferenceGateDecision {\n  return { action: 'block', details };\n}\n\nfunction spendDetails(\n  decision: HostedSpendDecision,\n): InferenceEntitlementDetails | null {\n  const by = decision.decidedBy;\n  if (!by) return null;\n  return {\n    policy: by.policy,\n    cap: by.cap,\n    spend: by.spend,\n    ...(by.resetsAt ? { resetsAt: by.resetsAt.toISOString() } : {}),\n  };\n}\n\n/**\n * Create the hosted inference gate. Register it with\n * {@link registerHostedInferenceGate}.\n */\nexport function createHostedInferenceGate(\n  options: HostedInferenceGateOptions,\n): HostedInferenceGate {\n  const principalOf = options.principal ?? getAmbientInferencePrincipal;\n  const requireSubscription = options.requireSubscription !== false;\n  const { killSwitch, spend } = options;\n\n  return {\n    async check(request) {\n      const principal = principalOf();\n      const tenantId = text(request.tenantId) ?? text(principal?.tenantId);\n\n      const state = await killSwitch.read(HOSTED_INFERENCE_KILL_SWITCH, {\n        ...(tenantId ? { tenantId } : {}),\n      });\n      if (state.enabled !== true) {\n        return block({\n          policy: 'kill-switch',\n          ...(state.disabledBy ? { disabledBy: state.disabledBy } : {}),\n        });\n      }\n      if (!tenantId) return block({ policy: 'no-tenant' });\n\n      // The per-user cap applies to the principal's own user, in its own\n      // tenant; a shared client (`userId: null`, agents) has none.\n      const userId =\n        request.userId === null ||\n        text(principal?.tenantId)?.toLowerCase() !== tenantId.toLowerCase()\n          ? undefined\n          : text(principal?.userId);\n\n      const decision = await spend.evaluate({\n        tenantId,\n        ...(userId ? { userId } : {}),\n      });\n      if (!decision.entitled && requireSubscription) {\n        return block({ policy: 'subscription' });\n      }\n      if (decision.state === 'blocked') {\n        const details = spendDetails(decision);\n        // A blocked decision always names its cap; refuse to guess if not.\n        if (!details) throw new Error('Hosted spend blocked without a cap.');\n        return block(details);\n      }\n      if (decision.state === 'warn') {\n        const details = spendDetails(decision);\n        if (details) {\n          try {\n            options.onWarning?.({\n              tenantId,\n              ...(userId ? { userId } : {}),\n              details,\n              request,\n            });\n          } catch {\n            // A warning sink never blocks or fails the call.\n          }\n          return { action: 'warn', details };\n        }\n      }\n      return { action: 'allow' };\n    },\n    invalidate(tenantId) {\n      spend.invalidate?.(tenantId);\n    },\n  };\n}\n\n/**\n * Register a hosted gate (or build one from options) with core's seam, and\n * the principal's user as the `userId` usage tag that per-user caps meter.\n * Returns the gate. To remove it, call core's `setInferenceGate(undefined)`\n * and `setAiUsageUserResolver(undefined)`.\n */\nexport function registerHostedInferenceGate(\n  gateOrOptions: HostedInferenceGate | HostedInferenceGateOptions,\n): HostedInferenceGate {\n  const isGate =\n    typeof (gateOrOptions as HostedInferenceGate).check === 'function';\n  const gate = isGate\n    ? (gateOrOptions as HostedInferenceGate)\n    : createHostedInferenceGate(gateOrOptions as HostedInferenceGateOptions);\n  const principalOf =\n    (!isGate && (gateOrOptions as HostedInferenceGateOptions).principal) ||\n    getAmbientInferencePrincipal;\n  setInferenceGate(gate);\n  setAiUsageUserResolver(() => text(principalOf()?.userId));\n  return gate;\n}\n\n/** Read the hosted kill switch (global, then `tenantId`). No model call. */\nexport async function getHostedInferenceSwitch(\n  killSwitch: HostedKillSwitchStore,\n  options: { tenantId?: string | null } = {},\n): Promise<HostedKillSwitchState> {\n  return killSwitch.read(\n    HOSTED_INFERENCE_KILL_SWITCH,\n    options.tenantId ? { tenantId: options.tenantId } : {},\n  );\n}\n\n/**\n * Turn hosted inference off (`enabled: false`) or back on, globally or for\n * one tenant: the incident lever. Takes effect on the next hosted call in\n * every process (the gate reads it uncached). Enabling a tenant does not\n * lift a global disable. The caller is the authorization: smrt-features'\n * `KillSwitchService.set()` writes the override rows directly (the CLI\n * holds database credentials); an admin UI writes through\n * `FeatureOverrideService` with its authorizer instead.\n */\nexport async function setHostedInferenceEnabled(\n  killSwitch: HostedKillSwitchStore,\n  options: { enabled: boolean; tenantId?: string | null },\n): Promise<HostedKillSwitchState> {\n  if (!killSwitch.set) {\n    throw new Error('This kill-switch store is read-only.');\n  }\n  return killSwitch.set(HOSTED_INFERENCE_KILL_SWITCH, {\n    enabled: options.enabled,\n    ...(options.tenantId !== undefined ? { tenantId: options.tenantId } : {}),\n  });\n}\n"],"mappings":";;;AAqDO,IAAM,+BAA+B;AAkF5C,SAAS,KAAK,OAAoC;CAChD,OAAO,OAAO,UAAU,YAAY,MAAM,KAAK,MAAM,KACjD,MAAM,KAAK,IACX,KAAA;AACN;AAEA,SAAS,MAAM,SAA6D;CAC1E,OAAO;EAAE,QAAQ;EAAS;CAAQ;AACpC;AAEA,SAAS,aACP,UACoC;CACpC,MAAM,KAAK,SAAS;CACpB,IAAI,CAAC,IAAI,OAAO;CAChB,OAAO;EACL,QAAQ,GAAG;EACX,KAAK,GAAG;EACR,OAAO,GAAG;EACV,GAAI,GAAG,WAAW,EAAE,UAAU,GAAG,SAAS,YAAY,EAAE,IAAI,CAAC;CAC/D;AACF;AAMO,SAAS,0BACd,SACqB;CACrB,MAAM,cAAc,QAAQ,aAAa;CACzC,MAAM,sBAAsB,QAAQ,wBAAwB;CAC5D,MAAM,EAAE,YAAY,UAAU;CAE9B,OAAO;EACL,MAAM,MAAM,SAAS;GACnB,MAAM,YAAY,YAAY;GAC9B,MAAM,WAAW,KAAK,QAAQ,QAAQ,KAAK,KAAK,WAAW,QAAQ;GAEnE,MAAM,QAAQ,MAAM,WAAW,KAAK,8BAA8B,EAChE,GAAI,WAAW,EAAE,SAAS,IAAI,CAAC,EACjC,CAAC;GACD,IAAI,MAAM,YAAY,MACpB,OAAO,MAAM;IACX,QAAQ;IACR,GAAI,MAAM,aAAa,EAAE,YAAY,MAAM,WAAW,IAAI,CAAC;GAC7D,CAAC;GAEH,IAAI,CAAC,UAAU,OAAO,MAAM,EAAE,QAAQ,YAAY,CAAC;GAInD,MAAM,SACJ,QAAQ,WAAW,QACnB,KAAK,WAAW,QAAQ,CAAA,EAAG,YAAY,MAAM,SAAS,YAAY,IAC9D,KAAA,IACA,KAAK,WAAW,MAAM;GAE5B,MAAM,WAAW,MAAM,MAAM,SAAS;IACpC;IACA,GAAI,SAAS,EAAE,OAAO,IAAI,CAAC;GAC7B,CAAC;GACD,IAAI,CAAC,SAAS,YAAY,qBACxB,OAAO,MAAM,EAAE,QAAQ,eAAe,CAAC;GAEzC,IAAI,SAAS,UAAU,WAAW;IAChC,MAAM,UAAU,aAAa,QAAQ;IAErC,IAAI,CAAC,SAAS,MAAM,IAAI,MAAM,qCAAqC;IACnE,OAAO,MAAM,OAAO;GACtB;GACA,IAAI,SAAS,UAAU,QAAQ;IAC7B,MAAM,UAAU,aAAa,QAAQ;IACrC,IAAI,SAAS;KACX,IAAI;MACF,QAAQ,YAAY;OAClB;OACA,GAAI,SAAS,EAAE,OAAO,IAAI,CAAC;OAC3B;OACA;MACF,CAAC;KACH,QAAQ,CAER;KACA,OAAO;MAAE,QAAQ;MAAQ;KAAQ;IACnC;GACF;GACA,OAAO,EAAE,QAAQ,QAAQ;EAC3B;EACA,WAAW,UAAU;GACnB,MAAM,aAAa,QAAQ;EAC7B;CACF;AACF;AAQO,SAAS,4BACd,eACqB;CACrB,MAAM,SACJ,OAAQ,cAAsC,UAAU;CAC1D,MAAM,OAAO,SACR,gBACD,0BAA0B,aAA2C;CACzE,MAAM,cACH,CAAC,UAAW,cAA6C,aAC1D;CACF,iBAAiB,IAAI;CACrB,6BAA6B,KAAK,YAAY,CAAA,EAAG,MAAM,CAAC;CACxD,OAAO;AACT;AAGA,eAAsB,yBACpB,YACA,UAAwC,CAAC,GACT;CAChC,OAAO,WAAW,KAChB,8BACA,QAAQ,WAAW,EAAE,UAAU,QAAQ,SAAS,IAAI,CAAC,CACvD;AACF;AAWA,eAAsB,0BACpB,YACA,SACgC;CAChC,IAAI,CAAC,WAAW,KACd,MAAM,IAAI,MAAM,sCAAsC;CAExD,OAAO,WAAW,IAAI,8BAA8B;EAClD,SAAS,QAAQ;EACjB,GAAI,QAAQ,aAAa,KAAA,IAAY,EAAE,UAAU,QAAQ,SAAS,IAAI,CAAC;CACzE,CAAC;AACH"}