From 4aabb7343ce26199fe1a53a44d0486d9f09b543a Mon Sep 17 00:00:00 2001 From: feco Date: Sun, 15 Nov 2026 20:46:30 +0000 Subject: [PATCH] Model tiers: per-model credits and premium/vip roles LLM_MODELS entries are now model[=credits][@role]. The default tiers follow the model comparison rated by an astrologer: Claude Haiku 5.5 (free, 1 credit), GPT-5.6 Terra (premium, 3 credits), Claude Opus 5.5 (vip, 10 credits). VIP includes premium, admins may use every model. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL --- crates/db/migrations/0004_tier_roles.sql | 5 + crates/db/src/lib.rs | 14 ++- docker-compose.yml | 3 +- services/backend/README.md | 19 +++- services/backend/src/config.rs | 111 ++++++++++++++++++++--- services/backend/src/routes/account.rs | 2 +- services/backend/src/routes/analyses.rs | 21 +++-- services/backend/src/routes/mod.rs | 2 +- services/backend/src/tests.rs | 25 +++++ services/worker/README.md | 7 +- 10 files changed, 180 insertions(+), 29 deletions(-) create mode 100644 crates/db/migrations/0004_tier_roles.sql diff --git a/crates/db/migrations/0004_tier_roles.sql b/crates/db/migrations/0004_tier_roles.sql new file mode 100644 index 0000000..c23bcc1 --- /dev/null +++ b/crates/db/migrations/0004_tier_roles.sql @@ -0,0 +1,5 @@ +-- Subscription tiers as roles: 'premium' and 'vip' unlock the models marked +-- for them in the backend's LLM_MODELS. +ALTER TABLE users DROP CONSTRAINT users_roles_valid; +ALTER TABLE users ADD CONSTRAINT users_roles_valid + CHECK (cardinality(roles) > 0 AND roles <@ ARRAY['admin', 'creator', 'premium', 'vip', 'user']::text[]); diff --git a/crates/db/src/lib.rs b/crates/db/src/lib.rs index 5d7c0ac..0fb02cf 100644 --- a/crates/db/src/lib.rs +++ b/crates/db/src/lib.rs @@ -27,16 +27,22 @@ pub enum Role { Admin, /// May write articles (phase 2). Creator, + /// Paid tier: may use the models marked `@premium`. + Premium, + /// Top tier: may use the `@vip` and `@premium` models. + Vip, User, } impl Role { - pub const ALL: [Role; 3] = [Role::Admin, Role::Creator, Role::User]; + pub const ALL: [Role; 5] = [Role::Admin, Role::Creator, Role::Premium, Role::Vip, Role::User]; pub fn as_str(self) -> &'static str { match self { Role::Admin => "admin", Role::Creator => "creator", + Role::Premium => "premium", + Role::Vip => "vip", Role::User => "user", } } @@ -63,6 +69,12 @@ impl User { self.roles.iter().any(|r| r == role.as_str()) } + /// Whether the user may use something that needs `role`: admins may use + /// everything, and the VIP tier includes the premium one. + pub fn has_access(&self, role: Role) -> bool { + self.has_role(role) || self.has_role(Role::Admin) || (role == Role::Premium && self.has_role(Role::Vip)) + } + pub fn role_list(&self) -> Vec { self.roles.iter().filter_map(|r| Role::parse(r)).collect() } diff --git a/docker-compose.yml b/docker-compose.yml index aa7d82a..6112cf0 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -47,7 +47,8 @@ services: COOKIE_SECURE: ${COOKIE_SECURE:-false} GOOGLE_CLIENT_IDS: ${GOOGLE_CLIENT_IDS:-} BOOTSTRAP_ADMIN_EMAILS: ${BOOTSTRAP_ADMIN_EMAILS:-} - LLM_MODELS: ${LLM_MODELS:-minimax/minimax-m3} + # Empty: the backend's default tiers (see services/backend/README.md). + LLM_MODELS: ${LLM_MODELS:-} depends_on: postgres: condition: service_healthy diff --git a/services/backend/README.md b/services/backend/README.md index 4191b03..bb6b953 100644 --- a/services/backend/README.md +++ b/services/backend/README.md @@ -17,8 +17,8 @@ Felhasználók, belépés, mentett születési képletek, szinasztriák és megh | `BOOTSTRAP_ADMIN_EMAILS` | – | ezek a címek regisztrációkor vagy belépéskor admin szerepet kapnak (így lesz meg az első admin) | | `SUPPORTED_LOCALES` | `hu,en` | felület- és elemzésnyelvek; az első az alapértelmezett | | `MONTHLY_FREE_CREDITS` | `10` | havi ingyenes kreditkeret | -| `ANALYSIS_COST` | `1` | egy új elemzés ára kreditben | -| `LLM_MODELS` | `minimax/minimax-m3` | választható OpenRouter-modellek; az első az alapértelmezett | +| `ANALYSIS_COST` | `1` | egy új elemzés ára kreditben azoknál a modelleknél, amelyeknél az `LLM_MODELS` nem ad meg árat | +| `LLM_MODELS` | lásd lent | választható modellek `modell[=kredit][@szerep]` alakban, vesszővel elválasztva; az első az alapértelmezett, és ahhoz nem kellhet szerep | | `ANALYSIS_PROMPT_VERSION` | `v1` | a prompt verziója (az elemzés-gyorsítótár kulcsának része) | | `MAX_CHARTS_PER_USER` | `50` | ennyi képletet menthet egy felhasználó | | `BIND_ADDR`, `LOG_FORMAT`, `RUST_LOG` | `0.0.0.0:8081`, `text`, `info` | | @@ -33,7 +33,7 @@ Felhasználók, belépés, mentett születési képletek, szinasztriák és megh - **Google:** a frontend a Google Identity Services gombbal vagy a One Tap felülettel szerez ID tokent, és elküldi a `POST /v1/auth/google` végpontra. A backend Google kulcsaival ellenőrzi az aláírást, a kiállítót és a kliens-azonosítót. - Ismeretlen Google-fióknál, ha a Google által igazolt e-mail-címmel már van felhasználó, ahhoz kapcsolja; ha nincs, újat hoz létre. - Ugyanaz a felhasználó több belépési móddal is rendelkezhet (`auth_identities`). A Facebook, az Apple és a passkey ugyanígy adható hozzá. -- **Szerepek** (`users.roles`, tömb): `user` (alap), `creator` (cikkírás, 2. fázis), `admin`. +- **Szerepek** (`users.roles`, tömb): `user` (alap), `creator` (cikkírás, 2. fázis), `premium` és `vip` (előfizetési szintek, amíg nincs fizetés, az admin osztja ki), `admin`. - **Guardok:** - `AuthUser`: belépés kell (401); - `AdminUser`: admin szerep is kell (403). @@ -99,7 +99,18 @@ Hibák formátuma: `{"error": {"code", "message"}}`. A születési adatok hibái ## Elemzések és kreditek -- **Kérés:** a `POST .../analyses` létrehoz egy `pending` elemzést, és levonja az `ANALYSIS_COST` kreditet; a szöveget a worker írja meg, általában 1–2 perc alatt. A kliens a `GET /v1/analyses/{id}` végponton kérdezi le az állapotát. Ha nincs elég kredit, 402 `insufficient_credits` a válasz. +- **Modellek és szintek:** az alapértelmezett beállítás + + ``` + LLM_MODELS=anthropic/claude-haiku-5.5=1,openai/gpt-5.6-terra=3@premium,anthropic/claude-opus-5.5=10@vip + ``` + + - **Haiku 5.5:** az ingyenes szint, 1 kredit. + - **GPT-5.6 Terra:** `premium` szerep kell hozzá, 3 kredit. + - **Opus 5.5:** privát/VIP célra, `vip` szerep kell hozzá, 10 kredit. + + A `vip` szerep a premium modelleket is megnyitja, az `admin` mindent. Szerep nélkül 403 `forbidden` a válasz. A `GET /v1/config` és a `GET /v1/credits` visszaadja a listát (`llm_models: [{id, credits, role}]`, illetve `default_model`). A választás egy 2026-11-ben, egy asztrológus értékelésével lefutott összevetésen alapul (lásd `services/worker/README.md`). +- **Kérés:** a `POST .../analyses` (`{language?, model?}`) létrehoz egy `pending` elemzést, és levonja a választott modell kreditárát; a szöveget a worker írja meg, általában 1–2 perc alatt. A kliens a `GET /v1/analyses/{id}` végponton kérdezi le az állapotát. Ha nincs elég kredit, 402 `insufficient_credits` a válasz. - **Gyorsítótár:** a kulcs `sha256(típus | képlet- vagy szinasztria-hash | promptverzió | modell | nyelv)`. - Ha ugyanarra a képletre már kértek ilyet, ugyanazt adja vissza (200). - Ha bárhol van kész elemzés ugyanezzel a kulccsal (például ugyanaz a születési adat egy másik felhasználónál), ingyen átmásolja (201, `done`). diff --git a/services/backend/src/config.rs b/services/backend/src/config.rs index f4fcc3c..769e4ea 100644 --- a/services/backend/src/config.rs +++ b/services/backend/src/config.rs @@ -1,6 +1,57 @@ //! Configuration from the environment. use anyhow::{Context, bail}; +use db::Role; +use serde::Serialize; + +/// A model users may choose for analyses. +#[derive(Debug, Clone, PartialEq, Serialize)] +pub struct LlmModel { + /// OpenRouter model id. + pub id: String, + /// Credits charged per new analysis. + pub credits: i32, + /// Role needed to use it (`None`: everyone). + pub role: Option, +} + +/// Parses `id[=credits][@role]` entries; `credits` defaults to `default_credits`. +fn parse_models(entries: &[String], default_credits: i32) -> anyhow::Result> { + entries + .iter() + .map(|entry| { + let (rest, role) = match entry.split_once('@') { + Some((rest, role)) => { + let role = Role::parse(role.trim()) + .with_context(|| format!("unknown role '{role}' in LLM_MODELS entry '{entry}'"))?; + (rest, Some(role)) + } + None => (entry.as_str(), None), + }; + let (id, credits) = match rest.split_once('=') { + Some((id, credits)) => ( + id, + credits + .trim() + .parse::() + .ok() + .filter(|c| *c >= 0) + .with_context(|| format!("invalid credits in LLM_MODELS entry '{entry}'"))?, + ), + None => (rest, default_credits), + }; + let id = id.trim(); + if id.is_empty() { + bail!("empty model id in LLM_MODELS entry '{entry}'"); + } + Ok(LlmModel { id: id.to_owned(), credits, role }) + }) + .collect() +} + +/// Free tier, paid tier, VIP tier (model choice of 2026-11). +const DEFAULT_LLM_MODELS: &str = + "anthropic/claude-haiku-5.5=1,openai/gpt-5.6-terra=3@premium,anthropic/claude-opus-5.5=10@vip"; #[derive(Debug, Clone)] pub struct Config { @@ -33,11 +84,11 @@ pub struct Config { pub supported_locales: Vec, /// `MONTHLY_FREE_CREDITS` (default 10). pub monthly_free_credits: i32, - /// `ANALYSIS_COST` credits per new analysis (default 1). - pub analysis_cost: i32, - /// `LLM_MODELS`: comma-separated OpenRouter model ids users may choose; - /// the first is the default (default `minimax/minimax-m3`). - pub llm_models: Vec, + /// `LLM_MODELS`: comma-separated `model[=credits][@role]` entries users + /// may choose from; the first is the default and should need no role. + /// Credits default to `ANALYSIS_COST` (default 1). Default: + /// [`DEFAULT_LLM_MODELS`]. + pub llm_models: Vec, /// `ANALYSIS_PROMPT_VERSION` (default `v1`); part of the analysis cache key. pub prompt_version: String, /// `MAX_CHARTS_PER_USER` (default 50). @@ -76,9 +127,17 @@ impl Config { if supported_locales.is_empty() { supported_locales = vec!["hu".into(), "en".into()]; } - let mut llm_models = list("LLM_MODELS"); - if llm_models.is_empty() { - llm_models.push("minimax/minimax-m3".into()); + let analysis_cost: i32 = parsed("ANALYSIS_COST", 1)?; + if analysis_cost < 0 { + bail!("ANALYSIS_COST must not be negative"); + } + let mut model_entries = list("LLM_MODELS"); + if model_entries.is_empty() { + model_entries = DEFAULT_LLM_MODELS.split(',').map(str::to_owned).collect(); + } + let llm_models = parse_models(&model_entries, analysis_cost)?; + if llm_models[0].role.is_some() { + bail!("the first LLM_MODELS entry is the default and must not need a role"); } let config = Self { database_url: var("DATABASE_URL").context("DATABASE_URL is required")?, @@ -94,7 +153,6 @@ impl Config { bootstrap_admin_emails: list("BOOTSTRAP_ADMIN_EMAILS").into_iter().map(|e| e.to_lowercase()).collect(), supported_locales, monthly_free_credits: parsed("MONTHLY_FREE_CREDITS", 10)?, - analysis_cost: parsed("ANALYSIS_COST", 1)?, llm_models, prompt_version: var("ANALYSIS_PROMPT_VERSION").unwrap_or_else(|| "v1".into()), max_charts_per_user: parsed("MAX_CHARTS_PER_USER", 50)?, @@ -102,8 +160,8 @@ impl Config { if config.session_ttl_days < 1 { bail!("SESSION_TTL_DAYS must be at least 1"); } - if config.monthly_free_credits < 0 || config.analysis_cost < 0 { - bail!("MONTHLY_FREE_CREDITS and ANALYSIS_COST must not be negative"); + if config.monthly_free_credits < 0 { + bail!("MONTHLY_FREE_CREDITS must not be negative"); } Ok(config) } @@ -124,10 +182,37 @@ impl Config { bootstrap_admin_emails: vec!["admin@example.com".into()], supported_locales: vec!["hu".into(), "en".into()], monthly_free_credits: 2, - analysis_cost: 1, - llm_models: vec!["openrouter/auto".into(), "anthropic/claude-test".into()], + llm_models: parse_models( + &["openrouter/auto".into(), "anthropic/claude-test=1".into(), "anthropic/claude-vip=2@vip".into()], + 1, + ) + .unwrap(), prompt_version: "v1".into(), max_charts_per_user: 50, } } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn parses_model_entries() { + let models = parse_models(&DEFAULT_LLM_MODELS.split(',').map(str::to_owned).collect::>(), 1).unwrap(); + assert_eq!( + models, + vec![ + LlmModel { id: "anthropic/claude-haiku-5.5".into(), credits: 1, role: None }, + LlmModel { id: "openai/gpt-5.6-terra".into(), credits: 3, role: Some(Role::Premium) }, + LlmModel { id: "anthropic/claude-opus-5.5".into(), credits: 10, role: Some(Role::Vip) }, + ] + ); + let models = parse_models(&["a/b:free".into(), "c/d@vip".into()], 2).unwrap(); + assert_eq!((models[0].id.as_str(), models[0].credits), ("a/b:free", 2)); + assert_eq!((models[1].credits, models[1].role), (2, Some(Role::Vip))); + assert!(parse_models(&["a/b@boss".into()], 1).is_err()); + assert!(parse_models(&["a/b=-1".into()], 1).is_err()); + assert!(parse_models(&["=3".into()], 1).is_err()); + } +} diff --git a/services/backend/src/routes/account.rs b/services/backend/src/routes/account.rs index 5f9393d..95cd8c9 100644 --- a/services/backend/src/routes/account.rs +++ b/services/backend/src/routes/account.rs @@ -123,7 +123,7 @@ pub async fn credits(State(state): St, auth: AuthUser) -> ApiResult> Ok(Json(json!({ "balance": balance, "monthly_free_credits": state.config.monthly_free_credits, - "analysis_cost": state.config.analysis_cost, + "llm_models": state.config.llm_models, "period": credits::current_period(), "ledger": ledger.into_iter().map(|(id, delta, reason, period, analysis_id, note, at)| json!({ "id": id, "delta": delta, "reason": reason, "period": period, diff --git a/services/backend/src/routes/analyses.rs b/services/backend/src/routes/analyses.rs index be27903..1bd181f 100644 --- a/services/backend/src/routes/analyses.rs +++ b/services/backend/src/routes/analyses.rs @@ -114,13 +114,20 @@ async fn request( req: AnalysisRequest, ) -> ApiResult<(StatusCode, Json)> { let language = validate_locale(state, Some(req.language.as_deref().unwrap_or(&auth.user.locale)))?; - let model = req.model.unwrap_or_else(|| state.config.llm_models[0].clone()); - if !state.config.llm_models.contains(&model) { - return Err(ApiError::BadRequest(format!( - "unknown model '{model}'; available: {}", - state.config.llm_models.join(", ") - ))); + let models = &state.config.llm_models; + let chosen = match &req.model { + None => &models[0], + Some(id) => models.iter().find(|m| &m.id == id).ok_or_else(|| { + let available: Vec<&str> = models.iter().map(|m| m.id.as_str()).collect(); + ApiError::BadRequest(format!("unknown model '{id}'; available: {}", available.join(", "))) + })?, + }; + if let Some(role) = chosen.role + && !auth.user.has_access(role) + { + return Err(ApiError::Forbidden(format!("the model '{}' needs the '{}' role", chosen.id, role.as_str()))); } + let model = chosen.id.clone(); let (kind, hash, chart_id, synastry_id) = match &target { Target::Natal { chart_id, hash } => ("natal", hash, Some(*chart_id), None), Target::Synastry { synastry_id, hash } => ("synastry", hash, None, Some(*synastry_id)), @@ -180,7 +187,7 @@ async fn request( } // New analysis: spend credits and queue it for the worker. - let cost = state.config.analysis_cost; + let cost = chosen.credits; let mut tx = state.db.begin().await?; let row: AnalysisRow = sqlx::query_as(&insert) .bind(id) diff --git a/services/backend/src/routes/mod.rs b/services/backend/src/routes/mod.rs index ca26a09..85ad279 100644 --- a/services/backend/src/routes/mod.rs +++ b/services/backend/src/routes/mod.rs @@ -116,7 +116,7 @@ async fn public_config(State(state): St) -> Json { "google_login": { "enabled": state.google.enabled(), "client_id": c.google_client_ids.first() }, "locales": c.supported_locales, "llm_models": c.llm_models, - "analysis_cost": c.analysis_cost, + "default_model": c.llm_models[0].id, "monthly_free_credits": c.monthly_free_credits, "password_min_length": crate::auth::MIN_PASSWORD_LEN, })) diff --git a/services/backend/src/tests.rs b/services/backend/src/tests.rs index e9f024c..f1dd4ef 100644 --- a/services/backend/src/tests.rs +++ b/services/backend/src/tests.rs @@ -556,5 +556,30 @@ async fn public_config_and_health(pool: PgPool) { assert_eq!(r.body["google_login"]["enabled"], true); assert_eq!(r.body["google_login"]["client_id"], GOOGLE_CLIENT); assert_eq!(r.body["locales"], json!(["hu", "en"])); + assert_eq!(r.body["default_model"], "openrouter/auto"); + assert_eq!(r.body["llm_models"][2], json!({"id": "anthropic/claude-vip", "credits": 2, "role": "vip"})); assert_eq!(app.get("/healthz", None).await.status, StatusCode::OK); } + +#[sqlx::test(migrator = "db::MIGRATOR")] +async fn tier_models_need_their_role(pool: PgPool) { + let app = TestApp::new(pool).await; + let anna = app.register("anna@example.com", "Anna").await; + let admin = app.register("admin@example.com", "Admin").await; + let chart = app.chart(&anna, "Saját", true, "1990-03-15").await; + let uri = format!("/v1/charts/{}/analyses", chart["id"].as_str().unwrap()); + let vip = json!({"model": "anthropic/claude-vip"}); + + let r = app.post(&uri, Some(&anna), vip.clone()).await; + assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::FORBIDDEN, Some("forbidden"))); + + let anna_id = app.get("/v1/me", Some(&anna)).await.body["user"]["id"].as_str().unwrap().to_string(); + let r = app + .call("PATCH", &format!("/v1/admin/users/{anna_id}"), Some(&admin), Some(json!({"roles": ["user", "vip"]}))) + .await; + assert_eq!(r.status, StatusCode::OK, "{}", r.body); + let r = app.post(&uri, Some(&anna), vip).await; + assert_eq!(r.status, StatusCode::ACCEPTED, "{}", r.body); + assert_eq!((r.body["model"].as_str(), &r.body["credits_charged"]), (Some("anthropic/claude-vip"), &json!(2))); + assert_eq!(app.get("/v1/credits", Some(&anna)).await.body["balance"], 0); +} diff --git a/services/worker/README.md b/services/worker/README.md index 86ff0d8..9e524be 100644 --- a/services/worker/README.md +++ b/services/worker/README.md @@ -36,7 +36,12 @@ Háttérmunkák a közös PostgreSQL-adatbázis fölött: e-mail-küldés, szöv ## Modellek összevetése -Az alapértelmezett modell (`LLM_MODELS`, backend) a `minimax/minimax-m3`. A 2026-11-15-i vak összevetésen a Gemini 4 Hydrogen és a Claude Sonnet 5.5 mellett ötöst kapott, és elemzésenként kb. 0,012 dollárba kerül; a másik kettő kb. 0,075 dollárba. +A 2026-11-15-i összevetésen két képletet hét modell írt meg; az egyiket a tulajdonos, a másikat egy hivatásos asztrológus pontozta. Ebből lettek a szintek (`LLM_MODELS`, backend): +- **Ingyenes:** Claude Haiku 5.5, kb. 0,006 dollár elemzésenként. +- **Fizetős:** GPT-5.6 Terra, kb. 0,05 dollár. +- **Privát/VIP:** Claude Opus 5.5, kb. 0,16 dollár. Az asztrológus szerint egyértelműen ez a legjobb. + +A MiniMax M3 olcsó, de az asztrológus szerint többször felcserélt dolgokat. ```bash OPENROUTER_API_KEY=... worker compare-models --chart natal.json \