@agentproto/model-catalog 0.2.0

package/dist/curation/index.d.ts

@@ -0,0 +1,98 @@
+import { C as CatalogKind, R as ResolvedModel } from '../index-BICjPG8H.js';
+import { CatalogVoice } from '../schema/voice.js';
+import '../catalog-aQHd559b.js';
+import '../base-BNHcMifc.js';
+import 'zod';
+import '../image/index.js';
+import '../video/index.js';
+import '../audio/index.js';
+import '../audio-BzVF_wke.js';
+
+/**
+ * Curation — what an app SURFACES from the catalog, distinct from
+ * model-access (who MAY use a model: tier/scope policy). Curation is the
+ * "feature/provider catalog" layer: an app composes views over the one
+ * registry ("all s2s voices from OpenAI OR Google", "images only", …)
+ * without touching the underlying data.
+ *
+ * Two registries, both following the canonical profile-registry shape
+ * (`listX()` / `getX(id)` throwing with the known-id list):
+ *
+ *   1. PROVIDER GROUPS — a company (`openai`) maps to every provider tag
+ *      it owns across kinds (`openai` for the LLM/audio company tag,
+ *      `openai-realtime` for its voice engine). This is what reconciles
+ *      the two provider vocabularies in the registry: audio MODELS are
+ *      tagged by company, voices by engine. Curating by group spans both.
+ *
+ *   2. SURFACE PROFILES — named presets (`voice-s2s`, `images`, …) an app
+ *      selects from. Permissive by default (`all`); apps narrow only when
+ *      a picker should diverge.
+ *
+ * Selection precedence (caller's job): per-call arg → per-app/guild
+ * config → env → `all` fallback.
+ */
+
+interface ProviderGroup {
+    /** Canonical company id, e.g. "openai", "google". */
+    id: string;
+    /** Display label. */
+    label: string;
+    /**
+     * Every provider tag this company owns across kinds. Audio/image/LLM use
+     * the company tag (`openai`); the voice engine uses its own (`openai-realtime`).
+     */
+    providers: readonly string[];
+}
+declare function listProviderGroups(): readonly ProviderGroup[];
+declare function getProviderGroup(id: string): ProviderGroup;
+/** The group that owns a raw provider tag, if any. */
+declare function groupForProvider(providerTag: string): ProviderGroup | undefined;
+/**
+ * Expand a mixed list of provider-group ids and raw provider tags into the
+ * flat set of provider tags to match against. A token that is a known
+ * group id expands to its members; anything else passes through as a raw
+ * tag (so callers can target an engine directly, e.g. `gemini-live`).
+ */
+declare function expandProviders(tokens: readonly string[]): string[];
+interface SurfaceProfile {
+    id: string;
+    description: string;
+    /** Restrict to these kinds. Undefined/empty = every kind. */
+    kinds?: readonly CatalogKind[];
+    /**
+     * Restrict to these provider GROUP ids or raw provider tags (OR-set).
+     * Expanded via `expandProviders`, so `["openai"]` covers both the
+     * `openai` company tag and the `openai-realtime` voice engine.
+     */
+    providers?: readonly string[];
+    /** Require all of these capability tags (AND-set): `s2s`, `tts`, `edit`, … */
+    capabilities?: readonly string[];
+    /** Require all of these arbitrary tags (AND-set). */
+    tags?: readonly string[];
+}
+declare function listSurfaceProfiles(): readonly SurfaceProfile[];
+declare function getSurfaceProfile(id: string): SurfaceProfile;
+/**
+ * True iff a model passes a surface profile. Provider membership, like
+ * capability/tag membership, is checked against the enrichment tag
+ * vocabulary (every kind emits its provider as a tag), so this is uniform
+ * across kinds and naturally spans the company/engine provider split.
+ */
+declare function modelMatchesProfile(model: ResolvedModel, profile: SurfaceProfile): boolean;
+/** Filter a model list down to what a surface profile exposes. */
+declare function applyProfile(models: ResolvedModel[], profile: SurfaceProfile): ResolvedModel[];
+/**
+ * The catalog as a surface profile exposes it — `applyProfile` over the
+ * full registry. The composable entry point for "show me this view".
+ */
+declare function listSurfaced(profile: SurfaceProfile): ResolvedModel[];
+/**
+ * Voice-list curation. The merged voice catalog (curated + live
+ * ElevenLabs) is `CatalogVoice[]`, not `ResolvedModel[]`, so it gets its
+ * own provider filter — same group-expansion semantics. Only the provider
+ * facet of a profile applies to a raw voice list (kind is implicitly
+ * voice; capability/tag live on the registry projection).
+ */
+declare function filterVoicesByProviders(voices: CatalogVoice[], providerTokens: readonly string[]): CatalogVoice[];
+
+export { type ProviderGroup, type SurfaceProfile, applyProfile, expandProviders, filterVoicesByProviders, getProviderGroup, getSurfaceProfile, groupForProvider, listProviderGroups, listSurfaceProfiles, listSurfaced, modelMatchesProfile };

package/dist/curation/index.mjs

@@ -0,0 +1,13 @@
+export { applyProfile, expandProviders, filterVoicesByProviders, getProviderGroup, getSurfaceProfile, groupForProvider, listProviderGroups, listSurfaceProfiles, listSurfaced, modelMatchesProfile } from '../chunk-CINXNTU3.mjs';
+import '../chunk-GH7PB5FB.mjs';
+import '../chunk-WTHHXXIK.mjs';
+import '../chunk-H6JUTF3U.mjs';
+import '../chunk-OHAMH3ZE.mjs';
+import '../chunk-QHELXPSL.mjs';
+import '../chunk-2LWYZOWB.mjs';
+import '../chunk-IJZ4XPO2.mjs';
+import '../chunk-WRUWNKDB.mjs';
+import '../chunk-SGJR6ZQH.mjs';
+import '../chunk-HEDDSOZF.mjs';
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/curation/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs"}

package/dist/evaluate-DisH3H7u.d.ts

@@ -0,0 +1,84 @@
+import { R as ResolvedModel } from './index-BICjPG8H.js';
+import { M as ModelKind } from './base-BNHcMifc.js';
+
+/**
+ * Access control types — workspace-override rules + app scope.
+ *
+ * v1 ships the evaluator + types; the DB-backed `model_access_rules`
+ * table follows in v2 (the MCP gen layer reads rows and threads them
+ * through `evaluateAccess` per workspace).
+ */
+
+type AccessEffect = "allow" | "block";
+type AccessTarget = {
+    kind: "model";
+    id: string;
+} | {
+    kind: "tag";
+    value: string;
+} | {
+    kind: "provider";
+    value: string;
+}
+/**
+ * `kind: "priceTier"` is the persisted DB discriminator string for
+ * catalog-price-tier targets (`low | mid | high | premium`). The
+ * conceptual name is `catalogPriceTier`; the literal stays `priceTier`
+ * to avoid breaking existing rows in `*_model_access_rules` tables.
+ */
+ | {
+    kind: "priceTier";
+    value: "low" | "mid" | "high" | "premium";
+} | {
+    kind: "kind";
+    value: ModelKind;
+};
+interface AccessRule {
+    effect: AccessEffect;
+    target: AccessTarget;
+    /** Audit reason; surfaced in decision.reason. */
+    reason?: string;
+}
+/**
+ * Per-product opt-in: the app declares which kinds it surfaces. Lets
+ * one app hide LLMs, another hide video, etc. Empty `kinds` means the app
+ * does not constrain by kind (admin / catalog-browser scope).
+ */
+interface AppScope {
+    kinds: ModelKind[];
+}
+
+/**
+ * Access evaluator — resolves whether a workspace can use a given model.
+ *
+ * Resolution order:
+ *   1. App scope — if the app opts out of the model's kind, deny.
+ *   2. Workspace explicit `model:<id>` rule — terminal allow or block.
+ *   3. Workspace tag / provider / priceTier / kind rules — most-specific
+ *      band wins. Within a band, block wins. Specificity ladder:
+ *        tag (4) > provider (3) > priceTier (2) > kind (1).
+ *      Rationale: an explicit `allow tag:image:generate` should beat a
+ *      blanket `block kind:llm`. The tag rule is the more specific
+ *      intent and reflects the operator's allowlist.
+ *   4. Catalog defaults — `lifecycle=stable && agentVisible=true` → allow.
+ *
+ * BYOK relaxation: when `byokActive`, `priceTier=premium` blocks are
+ * bypassed (BYOK users pay providers directly). NSFW / compliance
+ * blocks NEVER bypass.
+ */
+
+interface AccessEvalInput {
+    model: ResolvedModel;
+    appScope?: AppScope;
+    /** Workspace overrides; v1 callers pass `[]`. */
+    rules?: AccessRule[];
+    byokActive?: boolean;
+}
+interface AccessDecision {
+    allowed: boolean;
+    /** Stable token for logs/metrics. */
+    reason: string;
+}
+declare function evaluateAccess(input: AccessEvalInput): AccessDecision;
+
+export { type AccessDecision as A, type AccessEffect as a, type AccessEvalInput as b, type AccessRule as c, type AccessTarget as d, type AppScope as e, evaluateAccess as f };

package/dist/image/index.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Image Model Catalog — single source of truth for all image models.
+ *
+ * Migrated from `packages/integration/image/src/models/catalog.ts`. The
+ * original location now re-exports from here so every existing consumer
+ * (replicate-serializers, prompt blocks, an app UI) keeps working.
+ *
+ * Adding a model = 1 entry here + 1 serializer in
+ * `packages/integration/image/src/providers/replicate/replicate-serializers.ts`.
+ * Consumers import derived arrays (`AGENT_GENERATIVE_MODEL_IDS`, etc.)
+ * instead of hardcoding model names.
+ */
+interface ImageModelDefinition {
+    id: string;
+    name: string;
+    /** Replicate model ID (e.g. "google/nano-banana-pro") */
+    providerId: string;
+    provider: string;
+    capabilities: {
+        generate: boolean;
+        edit: boolean;
+        upscale?: boolean;
+    };
+    referenceImages: {
+        supported: boolean;
+        /** Replicate input field name for reference images */
+        fieldName: "image_input" | "input_images" | "input_image" | "none";
+        maxCount: number;
+        /** true for models that accept a single URI string (not array) */
+        singular: boolean;
+    };
+    aspectRatio: {
+        supported: string[];
+        default: string;
+    };
+    /** Response shape: "string" = single URI, "array" = array of URIs */
+    output: "string" | "array";
+    pricing: {
+        /** @deprecated Use billingUnit + baseCost instead */
+        costPerImage: number;
+        /** @deprecated Derived from baseCost */
+        costTier: "low" | "medium" | "high";
+        /** Always "per_image" for image models */
+        billingUnit: "per_image";
+        /** Our production cost in USD per image */
+        baseCost: number;
+        /**
+         * @deprecated Credits are derived at call time via
+         * `computeCenticredits({ baseCostUsd, category: "image" })`. Field kept
+         * optional for back-compat with existing entries; new entries
+         * should omit it. Use `overrideCreditCost` for strategic opt-outs.
+         */
+        creditCost?: number;
+        /**
+         * Bypass the markup formula and charge exactly this many credits
+         * per image. Use sparingly — most pricing should flow through the
+         * category markup so a global tune is one config change.
+         */
+        overrideCreditCost?: number;
+    };
+    description: string;
+    /** When false, model exists but isn't exposed in agent prompts/zod enums */
+    agentVisible: boolean;
+    /** Trigger word that must be included in the prompt to activate the fine-tune (e.g. "TOK") */
+    triggerWord?: string;
+}
+declare const IMAGE_MODEL_CATALOG: Record<string, ImageModelDefinition>;
+/** All model IDs */
+declare const IMAGE_MODEL_IDS: [string, ...string[]];
+/** Only models visible to agents (for zod enums + prompts) */
+declare const AGENT_IMAGE_MODEL_IDS: [string, ...string[]];
+/** Agent-visible models supporting generation */
+declare const AGENT_GENERATIVE_MODEL_IDS: [string, ...string[]];
+/** Agent-visible models supporting editing */
+declare const AGENT_EDITABLE_MODEL_IDS: [string, ...string[]];
+/** Generate a markdown table of agent-visible image models for prompt blocks */
+declare function generateImageModelTable(): string;
+
+export { AGENT_EDITABLE_MODEL_IDS, AGENT_GENERATIVE_MODEL_IDS, AGENT_IMAGE_MODEL_IDS, IMAGE_MODEL_CATALOG, IMAGE_MODEL_IDS, type ImageModelDefinition, generateImageModelTable };

package/dist/image/index.mjs

@@ -0,0 +1,3 @@
+export { AGENT_EDITABLE_MODEL_IDS, AGENT_GENERATIVE_MODEL_IDS, AGENT_IMAGE_MODEL_IDS, IMAGE_MODEL_CATALOG, IMAGE_MODEL_IDS, generateImageModelTable } from '../chunk-2LWYZOWB.mjs';
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/image/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs"}

package/dist/index-BICjPG8H.d.ts

@@ -0,0 +1,132 @@
+import { b as LLMPricing } from './catalog-aQHd559b.js';
+import { ImageModelDefinition } from './image/index.js';
+import { VideoModelDefinition } from './video/index.js';
+import { AudioModelDefinition } from './audio/index.js';
+import { CatalogVoice } from './schema/voice.js';
+
+/**
+ * Cross-kind registry. Resolves a model id against every catalog (LLM,
+ * image, video, audio) and returns a discriminated `ResolvedModel`.
+ *
+ * v1 returns the legacy per-kind data shapes verbatim — image/video keep
+ * `*ModelDefinition`, LLM keeps `LLMPricing`, audio surfaces voices.
+ * Callers (cost dispatcher, access evaluator) match on `.kind` and dig
+ * into the per-kind payload as needed.
+ */
+
+/**
+ * `audio` resolves to either an audio MODEL (priced TTS/STT) or a
+ * voice (downstream metadata). Most call sites care about the model
+ * (pricing, capabilities); a few (voice pickers) want the voice. They
+ * share the resolver but discriminate on the inner payload.
+ */
+type ResolvedModel = {
+    kind: "llm";
+    id: string;
+    canonicalId: string;
+    pricing: LLMPricing;
+} | {
+    kind: "image";
+    id: string;
+    def: ImageModelDefinition;
+} | {
+    kind: "video";
+    id: string;
+    def: VideoModelDefinition;
+} | {
+    kind: "audio";
+    id: string;
+    def: AudioModelDefinition;
+} | {
+    kind: "voice";
+    id: string;
+    voice: CatalogVoice;
+};
+/**
+ * Every kind the registry can resolve. Broader than the catalog
+ * `ModelKind` (llm/image/video/audio) because voices are a first-class
+ * registry kind but not a priced model family. Derived from
+ * `ResolvedModel` so it can never drift.
+ */
+type CatalogKind = ResolvedModel["kind"];
+/**
+ * Resolves a model id across every catalog.
+ *
+ * Lookup order: image → video → audio → LLM (last because LLM has the
+ * partial-prefix fallback that can match other strings if probed first).
+ *
+ * Returns `undefined` for unknown ids — callers decide whether to throw
+ * or fall back. LLM uses fallback pricing inside its own dispatcher
+ * (preserves existing behavior at the orchestrator).
+ */
+declare function getModel(id: string): ResolvedModel | undefined;
+/**
+ * Returns true iff the id is exposed to agents.
+ *
+ * - LLM: every entry in `LLM_PRICING_CATALOG` is considered visible
+ *   (legacy convention; refine in v2 with per-entry `agentVisible`).
+ * - Image / Video: respects the `agentVisible` flag.
+ * - Audio voices: all voices are visible (catalog itself is curated).
+ */
+declare function isAgentVisible(id: string): boolean;
+interface ListModelsFilter {
+    kind?: CatalogKind;
+    /** Single provider (back-compat). Folded into `providers` internally. */
+    provider?: string;
+    /** Provider OR-set — a model matches if its provider is any of these. */
+    providers?: string[];
+    /**
+     * Capability tags a model must carry (ALL of them). Capabilities are
+     * emitted as tags by enrichment — audio `tts`/`stt`/`s2s`, image
+     * `edit`/`upscale`, video `i2v`/`t2v` — so this filters on the same
+     * vocabulary `listModels({capabilities:["s2s"]})` would expect.
+     */
+    capabilities?: string[];
+    /** Arbitrary tags a model must carry (ALL of them). */
+    tags?: string[];
+    agentVisibleOnly?: boolean;
+}
+/**
+ * Cross-kind listing. Useful for catalog browsers and capability search.
+ * Returns `ResolvedModel[]` (discriminated by kind).
+ *
+ * Provider is an OR-set (`providers` ∪ the singular `provider`); capability
+ * and tag filters are AND-sets (a model must carry every listed value).
+ * Composed: `listModels({ kind:"audio", capabilities:["s2s"],
+ * providers:["gemini-live","openai-realtime"] })` → all s2s models from
+ * Gemini OR OpenAI.
+ */
+declare function listModels(filter?: ListModelsFilter): ResolvedModel[];
+/**
+ * Provider-centric view — every model a provider offers across all kinds
+ * (llm / image / video / audio incl. tts/stt/s2s). This is the "provider
+ * catalog" (openai, google, anthropic, replicate, openrouter, …): a
+ * derived query over the kind-organized catalogs, NOT a parallel store.
+ */
+declare function getModelsByProvider(provider: string): ResolvedModel[];
+/**
+ * Returns the platform a model's adapter is **statically pinned** to,
+ * if known. ONLY meaningful for image / video / audio — those adapters
+ * are constructed per-platform (Replicate adapter, MiniMax adapter…),
+ * so the model's `def.provider` IS the runtime connector.
+ *
+ * For LLM, returns `undefined` — the runtime connector is determined
+ * at call time by `pickLlmConnector(connectors, parseModelId(id).provider)`
+ * against the guild's installed connectors, NOT by the model id alone.
+ * The same `anthropic/claude-sonnet-4-5` can route through OpenRouter
+ * OR direct Anthropic depending on which connectors the guild has
+ * installed. Recording call sites MUST pass the actual `connectorUsed`
+ * they invoked; do not infer from id.
+ *
+ * Use case: image/video workflow steps fetch `model.def.provider`
+ * directly (no ambiguity). LLM call sites use the runtime resolver.
+ */
+declare function getStaticModelProvider(model: ResolvedModel): string | undefined;
+/**
+ * Resolves an id to its canonical catalog key across kinds. For ids that
+ * have no alias, returns the id unchanged. Used by callers that want to
+ * normalize before persisting (e.g., `byok_usage` rows).
+ */
+declare function resolveAlias(id: string): string;
+
+export { type CatalogKind as C, type ListModelsFilter as L, type ResolvedModel as R, getModelsByProvider as a, getStaticModelProvider as b, getModel as g, isAgentVisible as i, listModels as l, resolveAlias as r };

package/dist/index-D8nL3fPZ.d.ts

@@ -0,0 +1,171 @@
+import { A as AccessDecision } from './evaluate-DisH3H7u.js';
+import { a as CatalogPriceTier, L as Lifecycle, M as ModelKind } from './base-BNHcMifc.js';
+import { R as ResolvedModel } from './index-BICjPG8H.js';
+
+/**
+ * Model enrichment — `catalogPriceTier` / `tags` / `lifecycle` / `actions`
+ * per model id.
+ *
+ * Bridge between the legacy data shape (`ImageModelDefinition`,
+ * `VideoModelDefinition`, `LLMPricing`) and the v2 access-rule
+ * primitives that target by tier, tag, and action. Without this, rules
+ * like `priceTier:premium` and `tag:nsfw` would never match anything.
+ *
+ * Two layers:
+ *   1. Explicit map for the curated set we know about (overrides win).
+ *   2. Heuristic inference for any model not in the explicit map
+ *      (catalogPriceTier from creditCost / token rates; tags from kind +
+ *      provider).
+ *
+ * Actions (`<kind>:<verb>` — e.g. `image:generate`, `llm:tool_use`) are
+ * computed from per-kind capability objects via `getActions` and merged
+ * into `tags` so existing tag-based access rules match action targets
+ * without any evaluator change. The reserved `<kind>:` prefix is enforced
+ * by `assertReservedPrefixDiscipline` at module load — free-form curation
+ * tags must NOT use it.
+ *
+ * Add an entry to `EXPLICIT_ENRICHMENT` when you want exact control;
+ * skip it when defaults are good enough.
+ */
+
+interface ModelEnrichment {
+    catalogPriceTier: CatalogPriceTier;
+    /** Curation tags + action tags (`<kind>:<verb>`) merged. */
+    tags: readonly string[];
+    lifecycle: Lifecycle;
+    /** Action tags only — convenience subset of `tags`. */
+    actions: readonly string[];
+}
+/**
+ * Display price gauge level (1..5) for a model — the **visual** "price
+ * mostly" indicator (Low / Medium / High / Max / Ultra) the pickers and the
+ * estimator render as a bar. Distinct from {@link inferCatalogPriceTier}:
+ * that one drives 4-value *access* rules (`priceTier:premium`) and must stay a
+ * `CatalogPriceTier`; this is cosmetic and free to span 5 bands. Both bucket
+ * the same provider USD cost, so they move together by construction.
+ */
+declare function priceTierForModel(model: ResolvedModel): number;
+/**
+ * Resolve enrichment for any model. Explicit map wins; heuristic fallback
+ * fills the rest. Action tags (`<kind>:<verb>`) are derived from the
+ * model's capability fields and merged into `tags`. Always returns a
+ * value (never undefined).
+ */
+declare function getEnrichment(model: ResolvedModel): ModelEnrichment;
+declare function modelHasTag(model: ResolvedModel, tag: string): boolean;
+declare function modelHasAction(model: ResolvedModel, action: string): boolean;
+declare function modelMatchesCatalogPriceTier(model: ResolvedModel, tier: CatalogPriceTier): boolean;
+/**
+ * @deprecated Use `modelMatchesCatalogPriceTier`. Kept for back-compat
+ * with the v1 evaluator's switch case which still uses the
+ * `priceTier` discriminator string. The function itself routes to the
+ * canonical name.
+ */
+declare function modelMatchesPriceTier(model: ResolvedModel, tier: CatalogPriceTier): boolean;
+declare function modelMatchesKind(model: ResolvedModel, kind: ModelKind): boolean;
+
+/**
+ * Picker subpath — wire shapes returned by the per-app
+ * `GET /models/available` route. Single source of truth shared by:
+ *   - the server-side helper (an app-side model-access helper)
+ *   - the per-app SDK clients (e.g. an app SDK client)
+ *   - the cross-app picker hook (an app picker hook)
+ *
+ * Without this single source the hook + SDK previously drifted from
+ * the API contract and a fetcher in the app silently kept calling
+ * with a stale auth pattern after the cookie-auth migration.
+ */
+
+interface AvailableModelCapabilities {
+    generate?: boolean;
+    edit?: boolean;
+    upscale?: boolean;
+    textToVideo?: boolean;
+    imageToVideo?: boolean;
+    audio?: boolean;
+    subjectReference?: boolean;
+    tts?: boolean;
+    stt?: boolean;
+    s2s?: boolean;
+}
+interface AvailableModel {
+    id: string;
+    /** Canonical model id (LLM aliases collapse here). */
+    canonicalId: string;
+    /**
+     * Priced model kind. Typed `ModelKind` (not `CatalogKind`) on purpose: the
+     * picker never surfaces `voice` rows as `AvailableModel` — voices reach the
+     * UI through a separate path — so `voice` is intentionally out of range here.
+     */
+    kind: ModelKind;
+    displayName: string;
+    description: string;
+    enrichment: ModelEnrichment;
+    decision: AccessDecision;
+    capabilities: AvailableModelCapabilities;
+    /** Recommended pricing display (per provider unit). */
+    pricingHint?: string;
+    /**
+     * Audio models only: cost normalized to **per minute of speech**, the
+     * intuitive unit for the voice picker. TTS (billed per 1k chars) is
+     * converted via an assumed speaking rate; per-minute models pass through.
+     */
+    voiceHint?: string;
+    /**
+     * Relative price gauge level (1..{@link PRICE_TIER_SLOTS}) from
+     * `priceTierForModel` — the visual "price mostly" indicator the picker
+     * renders as a segmented bar instead of a raw number. 0 when unknown.
+     */
+    priceTier?: number;
+    /** Localized-agnostic tier name for `priceTier` (e.g. `"High"`). */
+    priceTierName?: string;
+}
+interface AvailableConnector {
+    id: string;
+    name: string;
+    /** Whether the actor's guild/workspace has a connected credential for this provider. */
+    byokAvailable: boolean;
+    models: AvailableModel[];
+}
+/** Number of segments in the price gauge. */
+declare const PRICE_TIER_SLOTS = 5;
+/**
+ * Display names for levels 1..{@link PRICE_TIER_SLOTS}, ascending price. Kept
+ * as brand tokens (not localized) so the gauge reads the same everywhere.
+ */
+declare const PRICE_TIER_NAMES: readonly ["Low", "Medium", "High", "Max", "Ultra"];
+/** Name for a gauge level (1-based); empty string when out of range. */
+declare function priceTierName(level: number): string;
+/**
+ * Unicode price gauge (e.g. `▰▰▱▱▱`) for text-only surfaces (WhatsApp, logs).
+ * Rich UIs read {@link AvailableModel.priceTier} and render styled segments.
+ */
+declare function priceTierBar(level: number, slots?: number): string;
+interface AvailableModelsActor {
+    appId: string;
+    userId: string;
+    tier?: string;
+    guildId?: string;
+}
+interface AvailableModelsResponse {
+    success: true;
+    actor: AvailableModelsActor;
+    connectors: AvailableConnector[];
+}
+interface ListAvailableModelsParams {
+    /** Restrict to one or more kinds. Empty = all kinds. */
+    kind?: ModelKind | ModelKind[];
+    /** Guild scope — joins guild-level connectors for BYOK badges. */
+    guildId?: string;
+    /** Include rules-blocked models (decision.allowed=false). Default true. */
+    includeBlocked?: boolean;
+    /** Include catalog entries with agentVisible=false. Default false. */
+    includeHidden?: boolean;
+    /**
+     * Curation surface-profile id (`voice-s2s`, `images`, …) the app exposes.
+     * Resolved server-side via `getSurfaceProfile`. Omitted = full catalog.
+     */
+    surface?: string;
+}
+
+export { type AvailableConnector as A, type ListAvailableModelsParams as L, type ModelEnrichment as M, PRICE_TIER_NAMES as P, type AvailableModel as a, type AvailableModelCapabilities as b, type AvailableModelsActor as c, type AvailableModelsResponse as d, modelHasTag as e, modelMatchesCatalogPriceTier as f, getEnrichment as g, modelMatchesKind as h, modelMatchesPriceTier as i, PRICE_TIER_SLOTS as j, priceTierBar as k, priceTierName as l, modelHasAction as m, priceTierForModel as p };