Merge main into prod: restart running generations, error log, retry notice, questions on relationship analyses
CI / test (push) Successful in 1m7s
CI / build (push) Successful in 19s
CI / deploy (push) Successful in 52s

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
This commit is contained in:
feco
2026-11-18 21:51:39 +00:00
co-authored by Claude Opus 5.5
29 changed files with 1174 additions and 103 deletions
+11 -6
View File
@@ -462,8 +462,8 @@ fn question_system(language: &str) -> String {
if language == "hu" {
let mut text = format!(
"Tapasztalt, empatikus, lélektani szemléletű asztrológus vagy a Sorsfonalak alkalmazásban. Az olvasó már \
megkapta a részletes elemzését (születési képletelemzést vagy éves előrejelzést), és most kérdez róla. Válaszolj a \
kérdésére.
megkapta a részletes elemzését (születési képletelemzést, kapcsolati elemzést vagy éves előrejelzést), és most kérdez \
róla. Válaszolj a kérdésére.
Szabályok:
- A válasz a megadott képletadatokon és az elemzésen alapuljon. Ne találj ki pozíciót, fényszöget, házat vagy dátumot, \
@@ -471,8 +471,10 @@ amely nincs az adatok között. Ha a kérdésre az adatok alapján nem lehet fel
amit a képlet erről mutat.
- Maradj összhangban az elemzéssel. Ha a kérdés olyan részletre vonatkozik, amelyet az elemzés nem tárgyalt, a \
képletadatokból egészítsd ki.
- Közvetlenül a kérdezőhöz szólj, tegező formában. Ha a kérdés két ember kapcsolatáról szól, csak abból beszélj, amit \
az adatok mutatnak.
- Közvetlenül a kérdezőhöz szólj, tegező formában. Kapcsolati elemzésnél (két képlet összevetése) a kérdező az egyik \
fél: ha a kérdésből nem derül ki, melyik, beszélj kettejükhöz („ti”, „kettőtök”). A feleket az adatokban Person 1 és \
Person 2 jelöli, a szövegben „az első fél” és „a második fél”. Ne feltételezd a nemüket és a kapcsolat jellegét, és \
csak abból beszélj, amit az adatok mutatnak.
- Hangnem: meleg, őszinte, megerősítő és konkrét. Ne légy fatalista: ne jósolj betegséget, halált, balesetet, \
terhességet vagy biztos eseményeket, és ne adj orvosi, jogi vagy pénzügyi tanácsot. Ha ilyet kérdeznek, kedvesen \
tereld a választ arra, amit az asztrológia valóban mutat: hajlamokra, időszakokra, lehetőségekre.
@@ -490,7 +492,8 @@ használhatsz.
}
format!(
"You are an experienced, warm and psychologically minded astrologer in the Sorsfonalak app. The reader has \
received their detailed analysis (a natal chart interpretation or a yearly forecast) and now asks a question about it. \
received their detailed analysis (a natal chart interpretation, a relationship analysis or a yearly forecast) and now \
asks a question about it. \
Answer it.
Write in {lang}.
@@ -499,7 +502,9 @@ Rules:
- Base the answer on the chart data and the analysis given. Never invent positions, aspects, houses or dates that are \
not listed. If the data cannot answer the question, say so honestly and describe what the chart does show about it.
- Stay consistent with the analysis; fill in details it did not cover from the chart data.
- Speak to the reader directly, in the informal second person.
- Speak to the reader directly, in the informal second person. On a relationship analysis the reader is one of the \
two people (Person 1 and Person 2 in the data); when it is unclear which, speak to both. Do not assume their genders \
or the type of relationship.
- Tone: warm, honest, empowering and concrete. Not fatalistic: no predictions of illness, death, accidents, pregnancy \
or certain events, and no medical, legal or financial advice; if asked, turn gently to what astrology does show \
(tendencies, periods, opportunities).
@@ -0,0 +1,26 @@
-- Every failed attempt of an analysis, an answer or a prompt test run, for the
-- admin error log. No foreign keys: the log outlives deleted items. Kept for
-- 90 days (worker cleanup).
CREATE TABLE generation_errors (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
created_at timestamptz NOT NULL DEFAULT now(),
source text NOT NULL CHECK (source IN ('analysis', 'question', 'preview')),
item_id uuid NOT NULL,
kind text NOT NULL,
model text NOT NULL,
attempt integer NOT NULL,
-- What happened next: tried again, the default model took over, or gave up.
outcome text NOT NULL CHECK (outcome IN ('retry', 'fallback', 'failed')),
error text NOT NULL,
seconds integer
);
CREATE INDEX generation_errors_created_idx ON generation_errors (created_at DESC);
CREATE INDEX generation_errors_item_idx ON generation_errors (item_id);
-- When the current text was asked for (a regeneration or an admin restart
-- sets it again): the waiting page counts from here.
ALTER TABLE analyses ADD COLUMN requested_at timestamptz NOT NULL DEFAULT now();
UPDATE analyses SET requested_at = created_at;
ALTER TABLE questions ADD COLUMN requested_at timestamptz NOT NULL DEFAULT now();
UPDATE questions SET requested_at = created_at;
+3 -2
View File
@@ -1,13 +1,14 @@
# Kérdések az elemzésekről
A kész részletes képletelemzés és éves előrejelzés alatt a felhasználó kérdezhet róla („Kérdezz az elemzésedről”). Minden kérdés egy `question` egységet használ; minden csomagban 3 jár, és külön is vehető (+5 kérdés, 1 000 Ft). Admin ingyen kérdez.
A kész részletes képletelemzés, kapcsolati elemzés és éves előrejelzés alatt a felhasználó kérdezhet róla („Kérdezz az elemzésedről”). Minden kérdés egy `question` egységet használ; minden csomagban 3 jár, és külön is vehető (+5 kérdés, 1 000 Ft). Admin ingyen kérdez.
## Hogyan készül a válasz
- **Modell:** a Modellek oldalon külön beállítható kérdés-válasz modell (alapból Opus 5.5). Ha a választott modell hibára fut, az alapmodell válaszol (tartalék).
- **Amit a modell kap:** a képlet tömör adatsorát (előrejelzésnél az év adatait is), magát az elemzést, az ugyanerre az elemzésre feltett korábbi legfeljebb 6 kérdést a válasszal, és az új kérdést. Születési dátum, hely, idő és név nem megy ki.
- **Amit a modell kap:** a képlet tömör adatsorát (kapcsolati elemzésnél mindkét képletet és az összevetést, előrejelzésnél az év adatait is), magát az elemzést, az ugyanerre az elemzésre feltett korábbi legfeljebb 6 kérdést a válasszal, és az új kérdést. Születési dátum, hely, idő és név nem megy ki.
- **Prompt:** az admin felületen szerkeszthető (Promptok → Kérdés-válasz). A szóhatár (`QUESTION_MAX_WORDS` = 250) a felhasználói üzenetben is benne van, így a prompt átírásától sem vész el. A kérdés legfeljebb 600 karakter.
- **Szabályok:** csak a képletből és az elemzésből válaszol, nem jósol betegséget, halált, balesetet, terhességet vagy biztos eseményt, nem ad orvosi, jogi, pénzügyi tanácsot; a nem asztrológiai kérdést udvariasan elhárítja; a kérdésben lévő utasításokat nem követi.
- **Kapcsolati elemzés:** az összevetés mindkét tagja kérdezhet (a saját kérdéseiből), és mindketten látják a kérdéseket és a válaszokat.
- **Egyszerre egy:** amíg egy kérdésre készül a válasz, újabb nem tehető fel ugyanarra az elemzésre (így a válaszok egymásra épülnek).
- **Hiba:** a worker újrapróbálja, mint az elemzéseket; végleges hibánál a kérdést visszaadja (egyszer).
- **Újragenerálás:** admin a válasz melletti ↻ gombbal újraírathatja (díjmentesen).
+2
View File
@@ -127,6 +127,8 @@ Hibák formátuma: `{"error": {"code", "message"}}`. A születési adatok hibái
- **Fizetős rész:** a részletes elemzés darabra megy. A képletelemzés egy `natal`, a szinasztria-elemzés egy `synastry` egységet von le (`credit_ledger.unit`). Az egységek csomagvásárlásból (Stripe, később) vagy admin jóváírásból jönnek. Havi ingyenes keret nincs.
- **Modell:** három beállítás az admin felületen, az OpenRouter listájából (`model_settings` tábla): az elemzések és az éves előrejelzés (képlet-, kapcsolati elemzés, előrejelzés) közös modellje, a kérdés-válasz modellje és a rövid összefoglalóé. Ha nincs beállítva, az `ANALYSIS_MODEL` / `SUMMARY_MODEL` (alapból mindkettő Opus 5.5, a 2026-11-es összevetés legjobbja, lásd `services/worker/README.md`). Csak kötött JSON-választ adó modell választható. A kliens nem választ modellt, és a modell neve felhasználónak sehol nem jelenik meg.
- **Tartalék:** ha a választott modell kétszer hibára fut (végleges hibánál egyszer), a worker az alapmodellel próbálja tovább (`fallback_model`, `on_fallback`); csak ha az is elbukik, jár vissza az egység. A Modellek oldal mutatja, hány szövegnél kellett az elmúlt 30 napban.
- **Hibanapló:** a worker minden sikertelen próbálkozást a `generation_errors` táblába ír (mi, melyik modell, hányadik kísérlet, mi lett: újrapróbálás, tartalék vagy végleges hiba, mennyi ideig tartott); az admin Hibanapló oldala mutatja (`GET /v1/admin/errors?source=&outcome=`), 90 napig őrizzük. A felhasználó a várakozó oldalon látja, ha az előző próbálkozás nem sikerült és újrapróbáljuk; a számláló a kérés idejétől (`requested_at`) mér.
- **Futó generálások:** a Modellek oldalon látszik minden készülő és sorban álló elemzés és válasz, a modelljével és azzal, amivel most indulna; újraindításkor a jelenlegi beállítással indul újra (`GET /v1/admin/jobs`, `POST /v1/admin/jobs/restart`). Minden kísérlet `started_at` értéke a „jegye”: az újraindítás törli, így a workerben még futó régi kísérlet nem írhatja felül az újat, és a worker 10 másodpercen belül eldobja.
- **Újragenerálás:** admin minden elemzést egyenként újraírathat (`POST /v1/admin/analyses/{id}/regenerate`): ugyanaz a sor (az azonosító és a megosztások maradnak), a jelenlegi prompttal és modellel, egységlevonás nélkül.
- **Újraszámolás:** számítási változás után a `backend recalculate` parancs minden mentett képletet, összevetést és előrejelzést újraszámol, majd minden elemzést újra sorba állít (egységlevonás nélkül).
- **Kérés:** a `POST .../analyses` (`{language?}`) létrehoz egy `pending` elemzést, és levon egy egységet; 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 egység, 402 `insufficient_credits` a válasz (`unit`, `balance` részletekkel). Hiba esetén a worker visszaadja az egységet.
+23 -24
View File
@@ -49,11 +49,16 @@ pub struct AnalysisRow {
pub credits_charged: i32,
pub created_at: OffsetDateTime,
pub completed_at: Option<OffsetDateTime>,
/// Attempts so far; above 1 the page says it is being tried again.
pub attempts: i32,
pub next_attempt_at: OffsetDateTime,
/// When the current text was asked for (set again by a regeneration).
pub requested_at: OffsetDateTime,
}
const ANALYSIS_COLUMNS: &str = "id, kind, chart_id, synastry_id, forecast_id, language, prompt_version, status, \
content, error, \
credits_charged, created_at, completed_at";
credits_charged, created_at, completed_at, attempts, next_attempt_at, requested_at";
impl AnalysisRow {
pub fn view(&self) -> Value {
@@ -71,6 +76,9 @@ impl AnalysisRow {
"credits_charged": self.credits_charged,
"created_at": rfc3339(self.created_at),
"completed_at": rfc3339_opt(self.completed_at),
"attempts": self.attempts,
"next_attempt_at": rfc3339(self.next_attempt_at),
"requested_at": rfc3339(self.requested_at),
})
}
}
@@ -146,7 +154,7 @@ async fn request(
/// The cache key and the prompt version of a new analysis. The cache key leaves
/// out the admin-edited prompt revision, so a chart keeps its analysis when the
/// prompt changes; copying from another chart needs the same revision.
async fn versions(
pub(super) async fn versions(
state: &AppState,
kind: &str,
hash: &str,
@@ -359,6 +367,17 @@ pub async fn request_for_forecast(
request(&state, &auth, Target::Forecast { forecast_id: forecast.id, hash: forecast.forecast_hash }, req).await
}
/// The hash of what the analysis is about (chart, comparison or forecast),
/// part of its cache key; `None` when that was deleted.
pub(super) async fn target_hash(db: &PgPool, row: &AnalysisRow) -> Result<Option<String>, sqlx::Error> {
let (query, id) = match row.kind.as_str() {
"synastry" => ("SELECT synastry_hash FROM synastries WHERE id = $1", row.synastry_id),
"forecast" => ("SELECT forecast_hash FROM forecasts WHERE id = $1", row.forecast_id),
_ => ("SELECT chart_hash FROM charts WHERE id = $1", row.chart_id),
};
sqlx::query_scalar(query).bind(id).fetch_optional(db).await
}
/// Admin: writes an analysis again in place (same id, so links stay), with the
/// current prompt and model. Nobody is charged.
pub async fn regenerate(
@@ -371,27 +390,7 @@ pub async fn regenerate(
return Err(ApiError::conflict("analysis_in_progress", "Ez az elemzés éppen készül."));
}
let kind = Kind::parse(&row.kind).ok_or_else(|| ApiError::Internal(format!("unknown kind {}", row.kind)))?;
let hash: Option<String> = match kind {
Kind::Question => None,
Kind::Natal | Kind::Summary => {
sqlx::query_scalar("SELECT chart_hash FROM charts WHERE id = $1")
.bind(row.chart_id)
.fetch_optional(&state.db)
.await?
}
Kind::Synastry => {
sqlx::query_scalar("SELECT synastry_hash FROM synastries WHERE id = $1")
.bind(row.synastry_id)
.fetch_optional(&state.db)
.await?
}
Kind::Forecast => {
sqlx::query_scalar("SELECT forecast_hash FROM forecasts WHERE id = $1")
.bind(row.forecast_id)
.fetch_optional(&state.db)
.await?
}
};
let hash = target_hash(&state.db, &row).await?;
let hash = hash.ok_or(ApiError::NotFound("analysis"))?;
let (model, fallback) = crate::models::models_for(&state, kind).await?;
let (cache_key, prompt_version) = versions(&state, kind.as_str(), &hash, &model, &row.language).await?;
@@ -400,7 +399,7 @@ pub async fn regenerate(
"UPDATE analyses SET status = 'pending', content = NULL, error = NULL, model_used = NULL, \
input_tokens = NULL, output_tokens = NULL, cost_usd = NULL, attempts = 0, next_attempt_at = now(), \
started_at = NULL, completed_at = NULL, model = $2, prompt_version = $3, cache_key = $4, \
fallback_model = $5, on_fallback = false \
fallback_model = $5, on_fallback = false, requested_at = now() \
WHERE id = $1 AND status IN ('done', 'failed') RETURNING {ANALYSIS_COLUMNS}"
))
.bind(id)
+73
View File
@@ -0,0 +1,73 @@
//! Admin: the error log of the analyses, answers and prompt test runs (every
//! failed attempt, written by the worker), newest first.
use axum::Json;
use axum::extract::{Query, State};
use axum_extra::extract::WithRejection;
use serde::Deserialize;
use serde_json::{Value, json};
use time::OffsetDateTime;
use uuid::Uuid;
use super::St;
use crate::auth::AdminUser;
use crate::error::{ApiError, ApiResult};
use crate::views::rfc3339;
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ErrorQuery {
limit: Option<i64>,
offset: Option<i64>,
/// `analysis`, `question` or `preview`.
source: Option<String>,
/// `retry`, `fallback` or `failed`.
outcome: Option<String>,
}
type Row = (i64, OffsetDateTime, String, Uuid, String, String, i32, String, String, Option<i32>, Option<String>);
pub async fn list(
State(state): St,
_admin: AdminUser,
WithRejection(Query(query), _): WithRejection<Query<ErrorQuery>, ApiError>,
) -> ApiResult<Json<Value>> {
let limit = query.limit.unwrap_or(100).clamp(1, 500);
let offset = query.offset.unwrap_or(0).max(0);
// Whose text it was: the requester of the analysis or the asker.
let rows: Vec<Row> = sqlx::query_as(
"SELECT e.id, e.created_at, e.source, e.item_id, e.kind, e.model, e.attempt, e.outcome, e.error, e.seconds, \
u.email \
FROM generation_errors e \
LEFT JOIN analyses a ON e.source = 'analysis' AND a.id = e.item_id \
LEFT JOIN questions q ON e.source = 'question' AND q.id = e.item_id \
LEFT JOIN prompt_previews p ON e.source = 'preview' AND p.id = e.item_id \
LEFT JOIN users u ON u.id = coalesce(a.requested_by, q.asked_by, p.created_by) \
WHERE ($1::text IS NULL OR e.source = $1) AND ($2::text IS NULL OR e.outcome = $2) \
ORDER BY e.id DESC LIMIT $3 OFFSET $4",
)
.bind(&query.source)
.bind(&query.outcome)
.bind(limit)
.bind(offset)
.fetch_all(&state.db)
.await?;
let (total, last_day): (i64, i64) = sqlx::query_as(
"SELECT count(*), count(*) FILTER (WHERE created_at > now() - interval '1 day') FROM generation_errors \
WHERE ($1::text IS NULL OR source = $1) AND ($2::text IS NULL OR outcome = $2)",
)
.bind(&query.source)
.bind(&query.outcome)
.fetch_one(&state.db)
.await?;
let errors: Vec<Value> = rows
.into_iter()
.map(|(id, at, source, item, kind, model, attempt, outcome, error, seconds, email)| {
json!({
"id": id, "created_at": rfc3339(at), "source": source, "item_id": item, "kind": kind, "model": model,
"attempt": attempt, "outcome": outcome, "error": error, "seconds": seconds, "user": email,
})
})
.collect();
Ok(Json(json!({ "errors": errors, "total": total, "last_day": last_day, "limit": limit, "offset": offset })))
}
+150
View File
@@ -0,0 +1,150 @@
//! Admin: the analyses and answers being written or waiting in the queue,
//! and restarting them with the models set now (e.g. after switching away
//! from a slow model). A restarted attempt that is still running in the
//! worker is dropped there and cannot overwrite the new one.
use std::collections::HashMap;
use analysis_prompt::Kind;
use axum::Json;
use axum::extract::State;
use axum_extra::extract::WithRejection;
use serde::Deserialize;
use serde_json::{Value, json};
use time::OffsetDateTime;
use uuid::Uuid;
use super::analyses::{find_analysis, target_hash, versions};
use super::{Body, St};
use crate::AppState;
use crate::auth::AdminUser;
use crate::error::ApiResult;
use crate::models::{Function, models_for};
use crate::views::{rfc3339, rfc3339_opt};
type JobRow = (
Uuid,
String,
String,
String,
Option<String>,
bool,
i32,
Option<OffsetDateTime>,
OffsetDateTime,
OffsetDateTime,
Option<String>,
);
const COLUMNS: &str =
"id, kind, status, model, fallback_model, on_fallback, attempts, started_at, created_at, next_attempt_at, error";
async fn open_jobs(state: &AppState) -> Result<Vec<(&'static str, JobRow)>, sqlx::Error> {
let analyses: Vec<JobRow> = sqlx::query_as(&format!(
"SELECT {COLUMNS} FROM analyses WHERE status IN ('pending', 'running') ORDER BY created_at"
))
.fetch_all(&state.db)
.await?;
let questions: Vec<JobRow> = sqlx::query_as(
"SELECT id, 'question', status, model, fallback_model, on_fallback, attempts, started_at, created_at, \
next_attempt_at, error \
FROM questions WHERE status IN ('pending', 'running') ORDER BY created_at",
)
.fetch_all(&state.db)
.await?;
Ok(analyses.into_iter().map(|r| ("analysis", r)).chain(questions.into_iter().map(|r| ("question", r))).collect())
}
pub async fn list(State(state): St, _admin: AdminUser) -> ApiResult<Json<Value>> {
Ok(Json(json!({ "jobs": views(&state).await? })))
}
async fn views(state: &AppState) -> Result<Vec<Value>, sqlx::Error> {
// The models a restart would use, per function.
let mut next: HashMap<&'static str, (String, Option<String>)> = HashMap::new();
for (function, kind) in
[(Function::Summary, Kind::Summary), (Function::Analysis, Kind::Natal), (Function::Question, Kind::Question)]
{
next.insert(function.key(), models_for(state, kind).await?);
}
Ok(open_jobs(state)
.await?
.into_iter()
.map(|(table, (id, kind, status, model, fallback, on_fallback, attempts, started, created, due, error))| {
let function = Function::of(Kind::parse(&kind).unwrap_or(Kind::Natal)).key();
let (next_model, next_fallback) = &next[function];
let active = if on_fallback { fallback.clone().unwrap_or_else(|| model.clone()) } else { model.clone() };
json!({
"id": id, "type": table, "kind": kind, "status": status, "model": active, "on_fallback": on_fallback,
"next_model": next_model, "next_fallback": next_fallback, "attempts": attempts,
"started_at": rfc3339_opt(started), "created_at": rfc3339(created), "next_attempt_at": rfc3339(due),
"error": error,
})
})
.collect())
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Restart {
/// The jobs to restart; all open ones when missing.
ids: Option<Vec<Uuid>>,
}
pub async fn restart(
State(state): St,
AdminUser(admin): AdminUser,
WithRejection(Json(req), _): Body<Restart>,
) -> ApiResult<Json<Value>> {
let mut restarted = 0;
for (table, (id, kind, ..)) in open_jobs(&state).await? {
if req.ids.as_ref().is_some_and(|ids| !ids.contains(&id)) {
continue;
}
let done = if table == "question" {
let language: String = sqlx::query_scalar("SELECT language FROM questions WHERE id = $1")
.bind(id)
.fetch_one(&state.db)
.await?;
let (model, fallback, prompt_version) = super::questions::model_and_version(&state, &language).await?;
sqlx::query(
"UPDATE questions SET status = 'pending', model = $2, fallback_model = $3, on_fallback = false, \
prompt_version = $4, attempts = 0, next_attempt_at = now(), started_at = NULL, error = NULL, \
requested_at = now() \
WHERE id = $1 AND status IN ('pending', 'running')",
)
.bind(id)
.bind(&model)
.bind(&fallback)
.bind(&prompt_version)
.execute(&state.db)
.await?
.rows_affected()
} else {
let Some(row) = find_analysis(&state.db, id).await? else { continue };
let Some(hash) = target_hash(&state.db, &row).await? else { continue };
let (model, fallback) = models_for(&state, Kind::parse(&kind).unwrap_or(Kind::Natal)).await?;
let (cache_key, prompt_version) = versions(&state, &kind, &hash, &model, &row.language).await?;
sqlx::query(
"UPDATE analyses SET status = 'pending', model = $2, fallback_model = $3, on_fallback = false, \
cache_key = $4, prompt_version = $5, attempts = 0, next_attempt_at = now(), started_at = NULL, \
error = NULL, requested_at = now() \
WHERE id = $1 AND status IN ('pending', 'running')",
)
.bind(id)
.bind(&model)
.bind(&fallback)
.bind(&cache_key)
.bind(&prompt_version)
.execute(&state.db)
.await?
.rows_affected()
};
restarted += done;
}
if restarted > 0 {
sqlx::query("SELECT pg_notify('analyses', '')").execute(&state.db).await?;
}
tracing::info!(admin = %admin.id(), restarted, "generations restarted");
Ok(Json(json!({ "restarted": restarted, "jobs": views(&state).await? })))
}
+5
View File
@@ -10,8 +10,10 @@ mod admin;
mod analyses;
mod auth;
mod charts;
mod errors;
mod forecasts;
mod invitations;
mod jobs;
mod models;
mod payments;
mod prompts;
@@ -116,6 +118,9 @@ pub fn router(state: Arc<AppState>) -> Router {
.route("/v1/admin/prompts/{kind}/{language}", axum::routing::put(prompts::save))
.route("/v1/admin/prompts/{kind}/{language}/preview", post(prompts::start_preview))
.route("/v1/admin/previews/{id}", get(prompts::get_preview))
.route("/v1/admin/errors", get(errors::list))
.route("/v1/admin/jobs", get(jobs::list))
.route("/v1/admin/jobs/restart", post(jobs::restart))
.route("/v1/admin/models", get(models::list))
.route("/v1/admin/models/catalog", get(models::catalog))
.route("/v1/admin/models/{kind}", axum::routing::put(models::save))
+16 -8
View File
@@ -1,5 +1,6 @@
//! Questions about a finished detailed analysis: a natal chart analysis or a
//! yearly forecast. Each question uses a `question` unit (admins ask for
//! Questions about a finished detailed analysis: a natal chart analysis, a
//! relationship (synastry) analysis or a yearly forecast. On a comparison both
//! people see the questions and answers. Each question uses a `question` unit (admins ask for
//! free). The worker answers with the question model of the admin page,
//! seeing the chart data, the analysis and the earlier questions about it.
@@ -23,7 +24,7 @@ use crate::error::{ApiError, ApiResult};
use crate::views::{rfc3339, rfc3339_opt};
/// The analyses that can be asked about.
const ASKABLE: [&str; 2] = ["natal", "forecast"];
const ASKABLE: [&str; 3] = ["natal", "synastry", "forecast"];
/// A safety cap per analysis.
const MAX_PER_ANALYSIS: i64 = 100;
@@ -39,10 +40,13 @@ pub struct QuestionRow {
pub credits_charged: i32,
pub created_at: OffsetDateTime,
pub completed_at: Option<OffsetDateTime>,
pub attempts: i32,
pub next_attempt_at: OffsetDateTime,
pub requested_at: OffsetDateTime,
}
const QUESTION_COLUMNS: &str =
"id, analysis_id, question, status, answer, error, credits_charged, created_at, completed_at";
const QUESTION_COLUMNS: &str = "id, analysis_id, question, status, answer, error, credits_charged, created_at, \
completed_at, attempts, next_attempt_at, requested_at";
impl QuestionRow {
pub fn view(&self) -> Value {
@@ -56,6 +60,9 @@ impl QuestionRow {
"credits_charged": self.credits_charged,
"created_at": rfc3339(self.created_at),
"completed_at": rfc3339_opt(self.completed_at),
"attempts": self.attempts,
"next_attempt_at": rfc3339(self.next_attempt_at),
"requested_at": rfc3339(self.requested_at),
})
}
}
@@ -66,7 +73,7 @@ async fn find_question(db: &PgPool, id: Uuid) -> Result<Option<QuestionRow>, sql
/// The question model (and its fallback) and the version of the question
/// prompt in force.
async fn model_and_version(
pub(super) async fn model_and_version(
state: &crate::AppState,
language: &str,
) -> Result<(String, Option<String>, String), sqlx::Error> {
@@ -109,7 +116,7 @@ pub async fn ask(
return Err(ApiError::NotFound("analysis"));
}
if !ASKABLE.contains(&analysis.kind.as_str()) {
return Err(ApiError::BadRequest("questions can be asked about a natal analysis or a forecast".into()));
return Err(ApiError::BadRequest("questions can be asked about a detailed analysis or a forecast".into()));
}
if analysis.status != "done" {
return Err(ApiError::conflict("analysis_not_ready", "Az elemzés még nem készült el."));
@@ -191,7 +198,8 @@ pub async fn regenerate(
let row: QuestionRow = sqlx::query_as(&format!(
"UPDATE questions SET status = 'pending', answer = NULL, error = NULL, model_used = NULL, input_tokens = NULL, \
output_tokens = NULL, cost_usd = NULL, attempts = 0, next_attempt_at = now(), started_at = NULL, \
completed_at = NULL, model = $2, prompt_version = $3, fallback_model = $4, on_fallback = false \
completed_at = NULL, model = $2, prompt_version = $3, fallback_model = $4, on_fallback = false, \
requested_at = now() \
WHERE id = $1 AND status IN ('done', 'failed') RETURNING {QUESTION_COLUMNS}"
))
.bind(id)
+109
View File
@@ -761,6 +761,18 @@ async fn synastry_analyses_use_synastry_units(pool: PgPool) {
app.get("/v1/credits", Some(&anna)).await.body["balance"],
json!({"natal": 1, "synastry": 0, "forecast": 0, "question": 0})
);
// questions can be asked about the relationship analysis too
let analysis = r.body["id"].as_str().unwrap().to_string();
sqlx::query("UPDATE analyses SET status = 'done', content = '{\"title\": \"Kettőtök\"}' WHERE kind = 'synastry'")
.execute(&app.pool)
.await
.unwrap();
grant_units(&app, &anna, "question", 1).await;
let r = app
.post(&format!("/v1/analyses/{analysis}/questions"), Some(&anna), json!({"question": "Mire figyeljünk?"}))
.await;
assert_eq!((r.status, r.body["status"].as_str()), (StatusCode::ACCEPTED, Some("pending")), "{}", r.body);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
@@ -1639,3 +1651,100 @@ async fn questions_about_an_analysis_use_question_units(pool: PgPool) {
);
assert_eq!(left().await, json!(5), "regenerating charges nobody");
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn admins_restart_open_generations_with_the_current_models(pool: PgPool) {
let app = TestApp::new(pool.clone()).await;
let admin = app.register("admin@example.com", "Admin").await;
let anna = app.register("anna@example.com", "Anna").await;
assert_eq!(app.get("/v1/admin/jobs", Some(&anna)).await.status, StatusCode::FORBIDDEN);
let put = |model: &str| {
let (app, admin, body) = (&app, &admin, json!({ "model": model }));
async move { app.call("PUT", "/v1/admin/models/analysis", Some(admin), Some(body)).await }
};
assert_eq!(put("openai/gpt-x").await.status, StatusCode::OK);
let chart = app.chart(&admin, "Saját", true, "1990-03-15").await;
let chart_id = chart["id"].as_str().unwrap();
let r = app.post(&format!("/v1/charts/{chart_id}/analyses"), Some(&admin), json!({})).await;
let id = r.body["id"].as_str().unwrap().to_string();
// the worker is writing it with the chosen model
sqlx::query("UPDATE analyses SET status = 'running', started_at = now(), attempts = 1 WHERE id = $1::uuid")
.bind(&id)
.execute(&pool)
.await
.unwrap();
// after switching back to the default, the list shows what a restart would use
assert_eq!(
app.call("PUT", "/v1/admin/models/analysis", Some(&admin), Some(json!({"model": null}))).await.status,
StatusCode::OK
);
let jobs = app.get("/v1/admin/jobs", Some(&admin)).await.body["jobs"].clone();
let job = jobs.as_array().unwrap().iter().find(|j| j["id"] == json!(id)).expect("the analysis is listed");
assert_eq!(
(&job["status"], &job["model"], &job["next_model"]),
(&json!("running"), &json!("openai/gpt-x"), &json!("anthropic/claude-test"))
);
let r = app.post("/v1/admin/jobs/restart", Some(&admin), json!({ "ids": [id] })).await;
assert_eq!((r.status, &r.body["restarted"]), (StatusCode::OK, &json!(1)), "{}", r.body);
let (status, model, fallback, started, attempts): (
String,
String,
Option<String>,
Option<time::OffsetDateTime>,
i32,
) = sqlx::query_as("SELECT status, model, fallback_model, started_at, attempts FROM analyses WHERE id = $1::uuid")
.bind(&id)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(
(status.as_str(), model.as_str(), fallback, started, attempts),
("pending", "anthropic/claude-test", None, None, 0)
);
// finished ones are left alone
sqlx::query("UPDATE analyses SET status = 'done', content = '{}'").execute(&pool).await.unwrap();
assert_eq!(app.post("/v1/admin/jobs/restart", Some(&admin), json!({})).await.body["restarted"], 0);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn admins_read_the_error_log(pool: PgPool) {
let app = TestApp::new(pool.clone()).await;
let admin = app.register("admin@example.com", "Admin").await;
let anna = app.register("anna@example.com", "Anna").await;
let chart = app.chart(&anna, "Saját", true, "1990-03-15").await;
let chart_id = chart["id"].as_str().unwrap();
let analysis: uuid::Uuid = sqlx::query_scalar("SELECT id FROM analyses WHERE chart_id = $1::uuid")
.bind(chart_id)
.fetch_one(&pool)
.await
.unwrap();
for (attempt, outcome) in [(1, "retry"), (2, "failed")] {
sqlx::query(
"INSERT INTO generation_errors (source, item_id, kind, model, attempt, outcome, error, seconds) \
VALUES ('analysis', $1, 'summary', 'cheap/model', $2, $3, 'answer cut off at the token limit', 301)",
)
.bind(analysis)
.bind(attempt)
.bind(outcome)
.execute(&pool)
.await
.unwrap();
}
assert_eq!(app.get("/v1/admin/errors", Some(&anna)).await.status, StatusCode::FORBIDDEN);
let r = app.get("/v1/admin/errors", Some(&admin)).await;
assert_eq!((r.status, &r.body["total"], &r.body["last_day"]), (StatusCode::OK, &json!(2), &json!(2)), "{}", r.body);
let first = &r.body["errors"][0];
assert_eq!(
(&first["outcome"], &first["attempt"], &first["user"], &first["seconds"]),
(&json!("failed"), &json!(2), &json!("anna@example.com"), &json!(301))
);
let r = app.get("/v1/admin/errors?outcome=retry", Some(&admin)).await;
assert_eq!(r.body["errors"].as_array().unwrap().len(), 1);
assert_eq!(app.get("/v1/admin/errors?source=question", Some(&admin)).await.body["total"], 0);
// users see the attempts of their analysis (the page says it is tried again)
let r = app.get(&format!("/v1/analyses/{analysis}"), Some(&anna)).await;
assert_eq!(r.body["attempts"], 0);
assert!(r.body["next_attempt_at"].is_string());
}
@@ -0,0 +1,155 @@
"use client";
import { useCallback, useEffect, useState } from "react";
import { api, errorText } from "@/lib/api";
import { formatDate } from "@/lib/astro";
import type { GenerationError } from "@/lib/types";
const PAGE = 100;
const SOURCES: Record<string, string> = { analysis: "Elemzés", question: "Kérdés-válasz", preview: "Prompt-próba" };
const KINDS: Record<string, string> = {
summary: "összefoglaló",
natal: "képletelemzés",
synastry: "kapcsolati",
forecast: "előrejelzés",
question: "válasz",
};
const OUTCOMES: Record<GenerationError["outcome"], { label: string; tone: string }> = {
retry: { label: "újrapróbálva", tone: "neutral" },
fallback: { label: "tartalék modell vette át", tone: "neutral" },
failed: { label: "végleg sikertelen", tone: "tense" },
};
interface Page {
errors: GenerationError[];
total: number;
last_day: number;
}
/** The admin error log with filters and paging. */
export function ErrorLog() {
const [source, setSource] = useState("");
const [outcome, setOutcome] = useState("");
const [errors, setErrors] = useState<GenerationError[] | null>(null);
const [total, setTotal] = useState(0);
const [lastDay, setLastDay] = useState(0);
const [busy, setBusy] = useState(false);
const [error, setError] = useState<string | null>(null);
const load = useCallback(
async (offset: number) => {
setBusy(true);
setError(null);
const params = new URLSearchParams({ limit: String(PAGE), offset: String(offset) });
if (source) params.set("source", source);
if (outcome) params.set("outcome", outcome);
try {
const page = await api<Page>(`/admin/errors?${params}`);
setErrors((all) => (offset === 0 ? page.errors : [...(all ?? []), ...page.errors]));
setTotal(page.total);
setLastDay(page.last_day);
} catch (e) {
setError(errorText(e));
} finally {
setBusy(false);
}
},
[source, outcome],
);
useEffect(() => {
load(0);
}, [load]);
return (
<section className="card" style={{ gap: 12 }}>
<div className="row" style={{ gap: 12, flexWrap: "wrap", alignItems: "flex-end" }}>
<div className="field">
<label htmlFor="error-source">Mi</label>
<select id="error-source" className="inp" value={source} onChange={(e) => setSource(e.target.value)}>
<option value="">mind</option>
{Object.entries(SOURCES).map(([v, l]) => (
<option key={v} value={v}>
{l}
</option>
))}
</select>
</div>
<div className="field">
<label htmlFor="error-outcome">Következmény</label>
<select id="error-outcome" className="inp" value={outcome} onChange={(e) => setOutcome(e.target.value)}>
<option value="">mind</option>
{Object.entries(OUTCOMES).map(([v, o]) => (
<option key={v} value={v}>
{o.label}
</option>
))}
</select>
</div>
<p className="hint" style={{ margin: 0 }}>
{total} bejegyzés, ebből {lastDay} az elmúlt 24 órában
</p>
<button type="button" className="btn btn-sm btn-ghost" onClick={() => load(0)} disabled={busy}>
Frissítés
</button>
</div>
{error && (
<p className="msg msg-error" role="alert">
{error}
</p>
)}
{errors === null ? (
<p className="muted">Betöltés…</p>
) : errors.length === 0 ? (
<p className="muted">Nincs hiba. 🎉</p>
) : (
<div className="table-wrap">
<table className="error-log">
<thead>
<tr>
<th>Időpont</th>
<th>Mi</th>
<th>Modell</th>
<th>Kísérlet</th>
<th>Következmény</th>
<th>Hiba</th>
</tr>
</thead>
<tbody>
{errors.map((e) => (
<tr key={e.id}>
<td className="num">{formatDate(e.created_at, true)}</td>
<td>
{SOURCES[e.source] ?? e.source}
{e.source !== "question" && ` (${KINDS[e.kind] ?? e.kind})`}
{e.user && <span className="hint">{e.user}</span>}
<code className="hint" title={e.item_id}>
{e.item_id.slice(0, 8)}
</code>
</td>
<td>
<code>{e.model}</code>
</td>
<td className="num">
{e.attempt}.{e.seconds !== null && <span className="hint">{e.seconds} mp</span>}
</td>
<td>
<span className={`outcome tone-${OUTCOMES[e.outcome].tone}`}>{OUTCOMES[e.outcome].label}</span>
</td>
<td className="error-text">{e.error}</td>
</tr>
))}
</tbody>
</table>
</div>
)}
{errors && errors.length < total && (
<button type="button" className="btn btn-sm" onClick={() => load(errors.length)} disabled={busy}>
{busy ? "Betöltés…" : "Régebbiek"}
</button>
)}
</section>
);
}
@@ -0,0 +1,27 @@
import type { Metadata } from "next";
import { notFound } from "next/navigation";
import { AdminNav } from "@/components/AdminNav";
import { requireMe } from "@/lib/server";
import { ErrorLog } from "./ErrorLog";
export const metadata: Metadata = { title: "Hibanapló" };
export default async function AdminErrorsPage() {
const me = await requireMe("/admin/hibak");
if (!me.user.roles.includes("admin")) notFound();
return (
<main className="page" style={{ maxWidth: 1180 }}>
<AdminNav current="/admin/hibak" />
<div className="page-head">
<h1>Hibanapló</h1>
<p className="muted">
Az elemzések, válaszok és prompt-próbák minden sikertelen próbálkozása, a legújabb elöl. A worker írja; 90 napig
őrizzük.
</p>
</div>
<ErrorLog />
</main>
);
}
@@ -6,6 +6,8 @@ import { api, errorText } from "@/lib/api";
import { formatDate } from "@/lib/astro";
import type { CatalogModel, ModelFunction } from "@/lib/types";
import { RunningJobs } from "./RunningJobs";
const LABELS: Record<ModelFunction["kind"], { title: string; about: string }> = {
summary: { title: "Tömör összefoglaló", about: "Ingyenes, minden új képlethez magától elkészül. Olcsó, gyors modell elég." },
analysis: {
@@ -66,6 +68,7 @@ export function AdminModels() {
{functions.map((f) => (
<FunctionModel key={f.kind} fn={f} catalog={catalog} onSaved={replace} />
))}
<RunningJobs />
</div>
);
}
@@ -0,0 +1,138 @@
"use client";
import { useCallback, useEffect, useState } from "react";
import { api, errorText } from "@/lib/api";
import type { AdminJob } from "@/lib/types";
const KINDS: Record<AdminJob["kind"], string> = {
summary: "Összefoglaló",
natal: "Képletelemzés",
synastry: "Kapcsolati elemzés",
forecast: "Éves előrejelzés",
question: "Kérdés-válasz",
};
const REFRESH_MS = 10_000;
function since(iso: string): string {
const minutes = Math.max(0, Math.round((Date.now() - new Date(iso).getTime()) / 60_000));
return minutes < 1 ? "most" : `${minutes} perce`;
}
/**
* Analyses and answers being written or waiting. A restart starts them again
* with the models set now; an attempt still running is dropped by the worker.
*/
export function RunningJobs() {
const [jobs, setJobs] = useState<AdminJob[] | null>(null);
const [busy, setBusy] = useState(false);
const [asking, setAsking] = useState(false);
const [message, setMessage] = useState<string | null>(null);
const [error, setError] = useState<string | null>(null);
const load = useCallback(() => {
api<{ jobs: AdminJob[] }>("/admin/jobs")
.then((d) => setJobs(d.jobs))
.catch((e) => setError(errorText(e)));
}, []);
useEffect(() => {
load();
const timer = setInterval(load, REFRESH_MS);
return () => clearInterval(timer);
}, [load]);
async function restart(ids?: string[]) {
setBusy(true);
setError(null);
setMessage(null);
try {
const r = await api<{ restarted: number; jobs: AdminJob[] }>("/admin/jobs/restart", { body: ids ? { ids } : {} });
setJobs(r.jobs);
setMessage(r.restarted > 0 ? `${r.restarted} generálás újraindítva.` : "Nem volt mit újraindítani.");
setAsking(false);
} catch (e) {
setError(errorText(e));
} finally {
setBusy(false);
}
}
const changed = (jobs ?? []).filter((j) => j.model !== j.next_model).length;
return (
<section className="card model-card" aria-labelledby="jobs-title">
<div className="model-head">
<div>
<h2 id="jobs-title">Futó generálások</h2>
<p className="hint">
Az éppen készülő és a sorban álló elemzések és válaszok. Újraindításkor mindegyik azzal a modellel indul újra,
ami most be van állítva; a még futó régi kérést a worker eldobja. Senkitől nem von le újabb egységet.
</p>
</div>
{jobs && jobs.length > 0 && (
<div className="regenerate">
{asking ? (
<>
<span className="hint">
{jobs.length} generálás indul újra{changed > 0 ? `, ebből ${changed} másik modellel` : ""}.
</span>
<button type="button" className="btn btn-sm" onClick={() => restart()} disabled={busy}>
{busy ? "Újraindítás…" : "Igen, mind"}
</button>
<button type="button" className="btn btn-sm btn-ghost" onClick={() => setAsking(false)} disabled={busy}>
Mégse
</button>
</>
) : (
<button type="button" className="btn btn-sm" onClick={() => setAsking(true)}>
↻ Mind újraindítása ({jobs.length})
</button>
)}
</div>
)}
</div>
{message && (
<p className="msg" role="status">
{message}
</p>
)}
{error && (
<p className="msg msg-error" role="alert">
{error}
</p>
)}
{jobs === null ? (
<p className="muted">Betöltés…</p>
) : jobs.length === 0 ? (
<p className="muted">Most semmi nem készül és semmi nem vár a sorban.</p>
) : (
<ul className="model-options">
{jobs.map((j) => (
<li key={j.id} className="job-row">
<span>
<strong>{KINDS[j.kind]}</strong>
<span className="hint">
{j.status === "running" && j.started_at
? `fut, ${since(j.started_at)} indult`
: `vár (kérve ${since(j.created_at)})`}
{j.attempts > 0 ? ` · ${j.attempts}. kísérlet` : ""}
{j.on_fallback ? " · tartalék modellel" : ""}
</span>
{j.error && <span className="hint">utolsó hiba: {j.error}</span>}
</span>
<span className="model-price">
<code>{j.model}</code>
{j.model !== j.next_model ? <strong>→ {j.next_model}</strong> : <span>újraindítva is ez</span>}
</span>
<button type="button" className="btn btn-sm btn-ghost" onClick={() => restart([j.id])} disabled={busy}>
↻
<span className="sr-only"> Újraindítás</span>
</button>
</li>
))}
</ul>
)}
</section>
);
}
@@ -40,7 +40,7 @@ const KINDS: { kind: PromptKind; id: string; label: string; about: string }[] =
id: "kerdesek",
label: "Kérdés-válasz",
about:
"A kész képletelemzésre vagy előrejelzésre feltett kérdések válasza (legfeljebb 250 szó). A modell kapja a képlet adatait, az elemzést és a korábbi kérdéseket; a Modellek oldalon beállított kérdés-válasz modell válaszol.",
"A kész képletelemzésre, kapcsolati elemzésre vagy előrejelzésre feltett kérdések válasza (legfeljebb 250 szó). A modell kapja a képlet adatait, az elemzést és a korábbi kérdéseket; a Modellek oldalon beállított kérdés-válasz modell válaszol.",
},
];
+1 -1
View File
@@ -22,7 +22,7 @@ const FAQ: [string, string][] = [
],
[
"Mit jelent a kérdés?",
"A kész részletes képletelemzésed vagy éves előrejelzésed alatt kérdezhetsz róla, például hogy mit jelent egy fényszög a munkádra nézve, vagy mire figyelj egy időszakban. A válasz a képleted és az elemzés alapján készül, legfeljebb 250 szóban. Minden csomagban 3 kérdés van, és külön is vehetsz még.",
"A kész képletelemzésed, kapcsolati elemzésed vagy éves előrejelzésed alatt kérdezhetsz róla, például hogy mit jelent egy fényszög a munkádra nézve, mire figyeljetek egy kapcsolatban, vagy mire figyelj egy időszakban. A válasz a képleted és az elemzés alapján készül, legfeljebb 250 szóban. Minden csomagban 3 kérdés van, és külön is vehetsz még.",
],
[
"Mire kell a személyhely?",
+13
View File
@@ -644,3 +644,16 @@ a.pair-row:hover strong { color: var(--gold); }
.qa-form { display: flex; flex-direction: column; gap: 8px; }
.qa-form textarea { resize: vertical; min-height: 84px; }
.hint.warn { color: var(--gold); }
.job-row { display: grid; grid-template-columns: minmax(0, 1fr) auto auto; gap: 12px; align-items: center; padding: 8px 12px; border: 1px solid var(--line); border-radius: 8px; }
.job-row > span:first-child { display: flex; flex-direction: column; min-width: 0; }
@media (max-width: 640px) { .job-row { grid-template-columns: minmax(0, 1fr) auto; } .job-row .model-price { grid-column: 1 / -1; align-items: flex-start; } }
.retry-notice { display: flex; flex-direction: column; gap: 4px; }
.retry-notice p { margin: 0; }
/* admin: error log */
.error-log { width: 100%; border-collapse: collapse; font-size: 14px; }
.error-log th, .error-log td { text-align: left; vertical-align: top; padding: 8px 10px; border-bottom: 1px solid var(--line); }
.error-log td > .hint, .error-log td > code { display: block; }
.error-log .error-text { overflow-wrap: anywhere; max-width: 460px; }
.error-log .outcome { white-space: nowrap; }
.error-log .outcome.tone-tense { color: var(--tense); font-weight: 600; }
@@ -129,6 +129,7 @@ export default async function ComparisonPage({ params }: { params: Promise<{ id:
isAdmin={me.user.roles.includes("admin")}
canPay={config?.mock_payments ?? false}
note={`Az elemzésben az első fél: ${name1}, a második fél: ${name2}.`}
questionsLeft={me.analyses_left.question ?? 0}
/>
),
},
@@ -5,6 +5,7 @@ const PAGES = [
{ href: "/admin/meghivok", label: "Meghívók" },
{ href: "/admin/promptok", label: "Promptok" },
{ href: "/admin/modellek", label: "Modellek" },
{ href: "/admin/hibak", label: "Hibanapló" },
];
/** Switches between the admin pages. */
@@ -4,13 +4,31 @@ import { useEffect, useState } from "react";
import { ZodiacWheel } from "./ZodiacWheel";
/** Slowly turning wheel with the elapsed time, while the LLM writes. */
export function AnalysisLoading({ title, text, compact = false }: { title?: string; text: string; compact?: boolean }) {
const [seconds, setSeconds] = useState(0);
/**
* Slowly turning wheel with the elapsed time, while the LLM writes. The time
* counts from `since` (when the text was asked for), so it does not start
* again from zero after a reload; without it, from when the wheel appeared.
*/
export function AnalysisLoading({
title,
text,
compact = false,
since,
}: {
title?: string;
text: string;
compact?: boolean;
since?: string;
}) {
const [start] = useState(() => {
const t = since ? Date.parse(since) : NaN;
return Number.isNaN(t) ? Date.now() : Math.min(t, Date.now());
});
const [seconds, setSeconds] = useState(() => Math.floor((Date.now() - start) / 1000));
useEffect(() => {
const t = setInterval(() => setSeconds((s) => s + 1), 1000);
const t = setInterval(() => setSeconds(Math.floor((Date.now() - start) / 1000)), 1000);
return () => clearInterval(t);
}, []);
}, [start]);
const elapsed = `${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, "0")}`;
return (
@@ -21,7 +39,7 @@ export function AnalysisLoading({ title, text, compact = false }: { title?: stri
<p className="muted" role="status">
{text}
</p>
<p className="hint" aria-hidden="true">
<p className="hint" aria-hidden="true" suppressHydrationWarning>
{elapsed}
</p>
</div>
@@ -8,9 +8,28 @@ import type { Question, UnitBalance } from "@/lib/types";
import { AnalysisLoading } from "./AnalysisLoading";
import { PackageChooser } from "./PackageCards";
import { RegenerateButton } from "./RegenerateButton";
import { RetryNotice } from "./RetryNotice";
import { Paragraphs } from "./Rich";
const MAX_CHARS = 600;
const TEXTS = {
natal: {
title: "Kérdezz az elemzésedről",
hint: "Mit jelent ez a te életedben, hogyan kapcsolódik két rész egymáshoz? A válasz a képleted és az elemzés alapján készül, legfeljebb 250 szóban.",
example: "Pl. Hogyan hat a Hold helyzete a kapcsolataimra?",
},
synastry: {
title: "Kérdezz a kapcsolatotokról",
hint: "Hol erősítitek egymást, mire figyeljetek egy vitában, mit ad nektek a kapcsolat? A válasz a két képlet és az elemzés alapján készül, legfeljebb 250 szóban. A kérdéseket és a válaszokat mindketten látjátok.",
example: "Pl. Hogyan kezeljük jobban a nézeteltéréseinket?",
},
forecast: {
title: "Kérdezz az előrejelzésedről",
hint: "Mire figyelj egy időszakban, mit hozhat egy tranzit a munkádban vagy a kapcsolataidban? A válasz az év adatai és az előrejelzés alapján készül, legfeljebb 250 szóban.",
example: "Pl. Mire figyeljek a nyári időszakban a munkámban?",
},
};
const POLL_MS = 3000;
const MAX_POLLS = 80; // 4 minutes
@@ -24,13 +43,14 @@ export function AnalysisQuestions({
left: initialLeft,
isAdmin,
canPay,
forecast = false,
about,
}: {
analysisId: string;
left: number;
isAdmin: boolean;
canPay: boolean;
forecast?: boolean;
/** What the analysis is about: the heading and the example question follow it. */
about: "natal" | "synastry" | "forecast";
}) {
const [questions, setQuestions] = useState<Question[] | null>(null);
const [left, setLeft] = useState(initialLeft);
@@ -114,11 +134,8 @@ export function AnalysisQuestions({
const canAsk = isAdmin || left > 0;
return (
<section className="questions" aria-labelledby={`${fieldId}-title`}>
<h3 id={`${fieldId}-title`}>Kérdezz {forecast ? "az előrejelzésedről" : "az elemzésedről"}</h3>
<p className="hint">
Mit jelent ez a te életedben, mire figyelj egy időszakban, hogyan kapcsolódik két rész egymáshoz? A válasz a képleted
és az elemzés alapján készül, legfeljebb 250 szóban.
</p>
<h3 id={`${fieldId}-title`}>{TEXTS[about].title}</h3>
<p className="hint">{TEXTS[about].hint}</p>
{questions?.map((q) => (
<article key={q.id} className="qa" aria-busy={q.status === "pending" || q.status === "running"}>
@@ -139,12 +156,21 @@ export function AnalysisQuestions({
<RegenerateButton<Question> url={`/admin/questions/${q.id}/regenerate`} onStarted={replace} />
)}
<p className="msg msg-error" role="alert">
Erre most nem sikerült válaszolni{q.credits_charged > 0 ? ", a kérdést visszaadtuk" : ""}. Kérdezz újra
egy kicsit később.
Erre többszöri próbálkozás után sem sikerült válaszolni
{q.credits_charged > 0 ? ". A kérdést visszaadtuk, így ingyen újra felteheted" : ""}. Kérdezz újra egy
kicsit később.
</p>
{isAdmin && q.error && <p className="hint">Hiba: {q.error}</p>}
</div>
) : (
<AnalysisLoading compact text="Készül a válasz, ez általában fél perc…" />
<>
<AnalysisLoading
compact
text="Készül a válasz, ez általában fél perc…"
since={q.requested_at ?? q.created_at}
/>
<RetryNotice status={q.status} error={q.error} nextAttemptAt={q.next_attempt_at} isAdmin={isAdmin} />
</>
)}
</article>
))}
@@ -160,9 +186,7 @@ export function AnalysisQuestions({
rows={3}
maxLength={MAX_CHARS}
value={text}
placeholder={
forecast ? "Pl. Mire figyeljek a nyári időszakban a munkámban?" : "Pl. Hogyan hat a Hold helyzete a kapcsolataimra?"
}
placeholder={TEXTS[about].example}
onChange={(e) => setText(e.target.value)}
disabled={busy || waiting}
/>
@@ -7,6 +7,7 @@ import type { Analysis } from "@/lib/types";
import { AnalysisLoading } from "./AnalysisLoading";
import { RegenerateButton } from "./RegenerateButton";
import { RetryNotice } from "./RetryNotice";
import { Rich } from "./Rich";
import { openTab } from "./Tabs";
@@ -102,7 +103,21 @@ export function ChartSummary({
Az összefoglaló most nem készült el. Töltsd újra az oldalt egy kicsit később.
</p>
) : (
<AnalysisLoading compact text="Az összefoglalód készül, ez néhány másodperc…" />
<>
<AnalysisLoading
compact
text="Az összefoglalód készül, ez néhány másodperc…"
since={summary?.requested_at ?? summary?.created_at}
/>
{summary && (
<RetryNotice
status={summary.status}
error={summary.error}
nextAttemptAt={summary.next_attempt_at}
isAdmin={isAdmin}
/>
)}
</>
)}
</>
)}
@@ -11,6 +11,7 @@ import { AnalysisLoading } from "./AnalysisLoading";
import { AnalysisQuestions } from "./AnalysisQuestions";
import { PackageChooser } from "./PackageCards";
import { RegenerateButton } from "./RegenerateButton";
import { RetryNotice } from "./RetryNotice";
import { AnalysisView } from "./AnalysisView";
const POLL_MS = 5000;
@@ -99,7 +100,7 @@ export function DetailedAnalysis({
canPay: boolean;
/** Shown above a finished analysis (e.g. who is the first and the second person). */
note?: string;
/** Questions left; given where questions can be asked (natal analysis, forecast). */
/** Questions left; given where questions can be asked. */
questionsLeft?: number;
}) {
const [analysis, setAnalysis] = useState<Analysis | null>(initial);
@@ -155,13 +156,13 @@ export function DetailedAnalysis({
)}
{note && <p className="hint">{note}</p>}
<AnalysisView content={analysis.content} kind={target.kind} />
{questionsLeft !== undefined && target.kind !== "synastry" && (
{questionsLeft !== undefined && (
<AnalysisQuestions
analysisId={analysis.id}
left={questionsLeft}
isAdmin={isAdmin}
canPay={canPay}
forecast={target.kind === "forecast"}
about={target.kind}
/>
)}
</section>
@@ -172,7 +173,15 @@ export function DetailedAnalysis({
return (
<section className="analysis-card" aria-label={t.eyebrow} aria-busy="true">
<span className="eyebrow">{t.eyebrow}</span>
<AnalysisLoading title={t.loadingTitle} text={t.loading} />
<AnalysisLoading title={t.loadingTitle} text={t.loading} since={analysis?.requested_at ?? analysis?.created_at} />
{analysis && (
<RetryNotice
status={analysis.status}
error={analysis.error}
nextAttemptAt={analysis.next_attempt_at}
isAdmin={isAdmin}
/>
)}
</section>
);
}
@@ -186,9 +195,15 @@ export function DetailedAnalysis({
<p className="muted">{t.about}</p>
<p className="ai-line">{AI_SHORT}</p>
{analysis?.status === "failed" && (
<p className="msg msg-error" role="alert">
Az előző kérés nem sikerült{isAdmin ? "" : ", az elemzést visszaadtuk a keretedbe"}. Próbáld újra.
<div className="msg msg-error" role="alert">
<p style={{ margin: 0 }}>
Az elemzés többszöri próbálkozás után sem készült el.
{isAdmin || analysis.credits_charged === 0
? " Próbáld újra."
: " A felhasznált egységet visszaadtuk, így ingyen újra kérheted."}
</p>
{isAdmin && analysis.error && <p className="hint">Hiba: {analysis.error}</p>}
</div>
)}
{error && (
<p className="msg msg-error" role="alert">
@@ -0,0 +1,28 @@
/**
* Shown while a text is being written again after a failed attempt: it is
* retried on its own, nothing to do. Admins also see the error.
*/
export function RetryNotice({
status,
error,
nextAttemptAt,
isAdmin = false,
}: {
status: string;
error?: string | null;
nextAttemptAt?: string;
isAdmin?: boolean;
}) {
if (!error || (status !== "pending" && status !== "running")) return null;
const wait = nextAttemptAt ? Math.round((Date.parse(nextAttemptAt) - Date.now()) / 60_000) : 0;
return (
<div className="msg retry-notice" role="status">
<p>
Az előző próbálkozás nem sikerült, ezért automatikusan újrapróbáljuk. Nem kell újra kérned, és nem kerül
többe.
{status === "pending" && wait >= 1 ? ` A következő próbálkozás kb. ${wait} perc múlva indul.` : ""}
</p>
{isAdmin && <p className="hint">Hiba: {error}</p>}
</div>
);
}
+42
View File
@@ -77,6 +77,9 @@ export interface Question {
credits_charged: number;
created_at: string;
completed_at: string | null;
attempts?: number;
next_attempt_at?: string;
requested_at?: string;
}
export interface PublicConfig {
@@ -232,6 +235,26 @@ export interface Analysis {
credits_charged: number;
created_at: string;
completed_at: string | null;
/** Attempts so far, and when the next one starts (while it is retried). */
attempts?: number;
next_attempt_at?: string;
/** When the current text was asked for: the waiting page counts from here. */
requested_at?: string;
}
/** Admin: one failed attempt in the error log. */
export interface GenerationError {
id: number;
created_at: string;
source: "analysis" | "question" | "preview";
item_id: string;
kind: string;
model: string;
attempt: number;
outcome: "retry" | "fallback" | "failed";
error: string;
seconds: number | null;
user: string | null;
}
export interface AdminUser {
@@ -266,6 +289,25 @@ export interface ModelFunction {
finished_30d: number;
}
/** Admin: an analysis or answer being written or waiting in the queue. */
export interface AdminJob {
id: string;
type: "analysis" | "question";
kind: "summary" | "natal" | "synastry" | "forecast" | "question";
status: "pending" | "running";
/** The model of the current attempt. */
model: string;
on_fallback: boolean;
/** What a restart would use now. */
next_model: string;
next_fallback: string | null;
attempts: number;
started_at: string | null;
created_at: string;
next_attempt_at: string;
error: string | null;
}
/** A model OpenRouter offers; prices in USD per million tokens. */
export interface CatalogModel {
id: string;
+92 -9
View File
@@ -47,6 +47,9 @@ pub struct Job {
/// The default model, when the chosen one is another (see the module docs).
pub fallback_model: Option<String>,
pub on_fallback: bool,
/// When this attempt started; also its token: an admin restart clears it,
/// so a superseded attempt neither writes its result nor keeps running.
pub started_at: time::OffsetDateTime,
}
impl Job {
@@ -125,7 +128,7 @@ impl Analyzer {
WHERE id = (SELECT id FROM analyses WHERE status = 'pending' AND next_attempt_at <= now() \
ORDER BY next_attempt_at LIMIT 1 FOR UPDATE SKIP LOCKED) \
RETURNING id, kind, chart_id, synastry_id, forecast_id, language, model, prompt_version, attempts, \
fallback_model, on_fallback",
fallback_model, on_fallback, started_at",
)
.fetch_optional(&self.db)
.await?;
@@ -250,6 +253,8 @@ impl Analyzer {
.await
}
Err(e) => {
self.log_error("preview", job.id, &job.kind, &job.model, 1, "failed", e.message(), started.elapsed())
.await;
sqlx::query(
"UPDATE prompt_previews SET status = 'failed', error = $2, completed_at = now() \
WHERE id = $1 AND status = 'running'",
@@ -273,12 +278,21 @@ impl Analyzer {
/// Writes one claimed analysis and records the outcome.
pub async fn handle(&self, job: Job) {
let started = Instant::now();
let result = match self.prompt_for(&job).await {
let work = async {
match self.prompt_for(&job).await {
Ok(prompt) => self.llm.complete(job.active_model(), &prompt).await.map(|mut c| {
prompt::polish(&job.language, &mut c.content);
c
}),
Err(e) => Err(e),
}
};
let result = tokio::select! {
result = work => result,
() = self.superseded("analyses", job.id, job.started_at) => {
tracing::info!(id = %job.id, "analysis restarted by an admin; this attempt is dropped");
return;
}
};
if let Err(e) = self.finish(&job, result, started.elapsed()).await {
tracing::error!(id = %job.id, error = %e, "saving the analysis result failed");
@@ -292,7 +306,7 @@ impl Analyzer {
sqlx::query(
"UPDATE analyses SET status = 'done', content = $2, model_used = $3, input_tokens = $4, \
output_tokens = $5, cost_usd = $6, error = NULL, completed_at = now() \
WHERE id = $1 AND status = 'running'",
WHERE id = $1 AND status = 'running' AND started_at = $7",
)
.bind(job.id)
.bind(&c.content)
@@ -300,6 +314,7 @@ impl Analyzer {
.bind(c.input_tokens)
.bind(c.output_tokens)
.bind(c.cost_usd)
.bind(job.started_at)
.execute(&self.db)
.await?;
tracing::info!(
@@ -309,15 +324,34 @@ impl Analyzer {
}
Err(e) => {
let can_fall_back = !job.on_fallback && job.fallback_model.is_some();
match next_step(&e, job.attempts, self.max_attempts, can_fall_back) {
let next = next_step(&e, job.attempts, self.max_attempts, can_fall_back);
let outcome = match next {
Next::Retry(_) => "retry",
Next::Fallback => "fallback",
Next::Fail => "failed",
};
self.log_error(
"analysis",
job.id,
&job.kind,
job.active_model(),
job.attempts,
outcome,
e.message(),
took,
)
.await;
match next {
Next::Retry(wait) => {
sqlx::query(
"UPDATE analyses SET status = 'pending', error = $2, \
next_attempt_at = now() + make_interval(secs => $3) WHERE id = $1 AND status = 'running'",
next_attempt_at = now() + make_interval(secs => $3) \
WHERE id = $1 AND status = 'running' AND started_at = $4",
)
.bind(job.id)
.bind(e.message())
.bind(wait.as_secs_f64())
.bind(job.started_at)
.execute(&self.db)
.await?;
tracing::warn!(id = %job.id, attempts = job.attempts, retry_in_secs = wait.as_secs(), error = %e.message(), "analysis will be retried");
@@ -325,10 +359,11 @@ impl Analyzer {
Next::Fallback => {
sqlx::query(
"UPDATE analyses SET status = 'pending', error = $2, on_fallback = true, attempts = 0, \
next_attempt_at = now() WHERE id = $1 AND status = 'running'",
next_attempt_at = now() WHERE id = $1 AND status = 'running' AND started_at = $3",
)
.bind(job.id)
.bind(e.message())
.bind(job.started_at)
.execute(&self.db)
.await?;
tracing::warn!(
@@ -337,7 +372,7 @@ impl Analyzer {
);
}
Next::Fail => {
self.fail(job.id, e.message()).await?;
self.fail(job.id, job.started_at, e.message()).await?;
tracing::error!(id = %job.id, attempts = job.attempts, error = %e.message(), "analysis failed");
}
}
@@ -347,14 +382,15 @@ impl Analyzer {
}
/// Marks the analysis failed and gives its unit back (once).
async fn fail(&self, id: Uuid, message: &str) -> Result<(), sqlx::Error> {
async fn fail(&self, id: Uuid, started_at: time::OffsetDateTime, message: &str) -> Result<(), sqlx::Error> {
let mut tx = self.db.begin().await?;
let row: Option<(Option<Uuid>, i32, String)> = sqlx::query_as(
"UPDATE analyses SET status = 'failed', error = $2, completed_at = now() \
WHERE id = $1 AND status = 'running' RETURNING requested_by, credits_charged, kind",
WHERE id = $1 AND status = 'running' AND started_at = $3 RETURNING requested_by, credits_charged, kind",
)
.bind(id)
.bind(message)
.bind(started_at)
.fetch_optional(&mut *tx)
.await?;
if let Some((Some(user), units, kind)) = row
@@ -407,6 +443,53 @@ impl Analyzer {
Ok(result.rows_affected())
}
/// Records a failed attempt in the admin error log (a failure here is only logged).
#[allow(clippy::too_many_arguments)]
pub(crate) async fn log_error(
&self,
source: &str,
item_id: Uuid,
kind: &str,
model: &str,
attempt: i32,
outcome: &str,
error: &str,
took: Duration,
) {
let result = sqlx::query(
"INSERT INTO generation_errors (source, item_id, kind, model, attempt, outcome, error, seconds) \
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)",
)
.bind(source)
.bind(item_id)
.bind(kind)
.bind(model)
.bind(attempt)
.bind(outcome)
.bind(error.chars().take(2000).collect::<String>())
.bind(i32::try_from(took.as_secs()).unwrap_or(i32::MAX))
.execute(&self.db)
.await;
if let Err(e) = result {
tracing::error!(error = %e, "writing the error log");
}
}
/// Resolves when this attempt is no longer the current one (an admin
/// restarted it); checked every 10 seconds, never on a database error.
async fn superseded(&self, table: &str, id: Uuid, started_at: time::OffsetDateTime) {
let query = format!("SELECT status = 'running' AND started_at = $2 FROM {table} WHERE id = $1");
loop {
tokio::time::sleep(Duration::from_secs(10)).await;
match sqlx::query_scalar::<_, Option<bool>>(&query).bind(id).bind(started_at).fetch_optional(&self.db).await
{
Ok(Some(Some(true))) => {}
Ok(_) => return,
Err(_) => {}
}
}
}
/// On shutdown: analyses still being written go back to `pending` at once.
async fn release_running(&self) {
let ids: Vec<Uuid> = self.running.lock().unwrap().drain().collect();
+42 -11
View File
@@ -27,6 +27,8 @@ pub struct QuestionJob {
pub created_at: time::OffsetDateTime,
pub fallback_model: Option<String>,
pub on_fallback: bool,
/// The token of this attempt (see `Job::started_at`).
pub started_at: time::OffsetDateTime,
}
impl Analyzer {
@@ -37,7 +39,7 @@ impl Analyzer {
WHERE id = (SELECT id FROM questions WHERE status = 'pending' AND next_attempt_at <= now() \
ORDER BY next_attempt_at LIMIT 1 FOR UPDATE SKIP LOCKED) \
RETURNING id, analysis_id, question, language, model, prompt_version, attempts, created_at, \
fallback_model, on_fallback",
fallback_model, on_fallback, started_at",
)
.fetch_optional(&self.db)
.await?;
@@ -49,8 +51,9 @@ impl Analyzer {
async fn question_prompt(&self, job: &QuestionJob) -> Result<prompt::Prompt, LlmError> {
let db_err = |e: sqlx::Error| LlmError::Transient(format!("database: {e}"));
let (kind, chart_id, forecast_id, content): (String, Option<Uuid>, Option<Uuid>, Option<Value>) =
sqlx::query_as("SELECT kind, chart_id, forecast_id, content FROM analyses WHERE id = $1")
type Row = (String, Option<Uuid>, Option<Uuid>, Option<Uuid>, Option<Value>);
let (kind, chart_id, synastry_id, forecast_id, content): Row =
sqlx::query_as("SELECT kind, chart_id, synastry_id, forecast_id, content FROM analyses WHERE id = $1")
.bind(job.analysis_id)
.fetch_optional(&self.db)
.await
@@ -60,6 +63,7 @@ impl Analyzer {
let content = content.ok_or_else(|| LlmError::Permanent("the analysis has no text".into()))?;
let chart_text = match kind {
Kind::Forecast => self.forecast_text(forecast_id).await?,
Kind::Synastry => self.synastry_text(synastry_id).await?,
_ => self.natal_text(chart_id).await?,
};
let analysis = prompt::to_markdown(kind, &job.language, &content);
@@ -91,7 +95,8 @@ impl Analyzer {
/// Answers one claimed question and records the outcome.
pub async fn handle_question(&self, job: QuestionJob) {
let started = Instant::now();
let result = match self.question_prompt(&job).await {
let work = async {
match self.question_prompt(&job).await {
Ok(p) => {
let model = active_model(&job.model, job.fallback_model.as_deref(), job.on_fallback);
self.llm.complete(model, &p).await.map(|mut c| {
@@ -100,6 +105,14 @@ impl Analyzer {
})
}
Err(e) => Err(e),
}
};
let result = tokio::select! {
result = work => result,
() = self.superseded("questions", job.id, job.started_at) => {
tracing::info!(id = %job.id, "answer restarted by an admin; this attempt is dropped");
return;
}
};
if let Err(e) = self.finish_question(&job, result, started.elapsed()).await {
tracing::error!(id = %job.id, error = %e, "saving the answer failed");
@@ -119,7 +132,7 @@ impl Analyzer {
sqlx::query(
"UPDATE questions SET status = 'done', answer = $2, model_used = $3, input_tokens = $4, \
output_tokens = $5, cost_usd = $6, error = NULL, completed_at = now() \
WHERE id = $1 AND status = 'running'",
WHERE id = $1 AND status = 'running' AND started_at = $7",
)
.bind(job.id)
.bind(&answer)
@@ -127,6 +140,7 @@ impl Analyzer {
.bind(c.input_tokens)
.bind(c.output_tokens)
.bind(c.cost_usd)
.bind(job.started_at)
.execute(&self.db)
.await?;
tracing::info!(
@@ -136,15 +150,25 @@ impl Analyzer {
}
Err(e) => {
let can_fall_back = !job.on_fallback && job.fallback_model.is_some();
match next_step(&e, job.attempts, self.max_attempts, can_fall_back) {
let next = next_step(&e, job.attempts, self.max_attempts, can_fall_back);
let outcome = match next {
Next::Retry(_) => "retry",
Next::Fallback => "fallback",
Next::Fail => "failed",
};
let model = active_model(&job.model, job.fallback_model.as_deref(), job.on_fallback);
self.log_error("question", job.id, "question", model, job.attempts, outcome, e.message(), took).await;
match next {
Next::Retry(wait) => {
sqlx::query(
"UPDATE questions SET status = 'pending', error = $2, \
next_attempt_at = now() + make_interval(secs => $3) WHERE id = $1 AND status = 'running'",
next_attempt_at = now() + make_interval(secs => $3) \
WHERE id = $1 AND status = 'running' AND started_at = $4",
)
.bind(job.id)
.bind(e.message())
.bind(wait.as_secs_f64())
.bind(job.started_at)
.execute(&self.db)
.await?;
tracing::warn!(id = %job.id, attempts = job.attempts, error = %e.message(), "answer will be retried");
@@ -152,10 +176,11 @@ impl Analyzer {
Next::Fallback => {
sqlx::query(
"UPDATE questions SET status = 'pending', error = $2, on_fallback = true, attempts = 0, \
next_attempt_at = now() WHERE id = $1 AND status = 'running'",
next_attempt_at = now() WHERE id = $1 AND status = 'running' AND started_at = $3",
)
.bind(job.id)
.bind(e.message())
.bind(job.started_at)
.execute(&self.db)
.await?;
tracing::warn!(
@@ -164,7 +189,7 @@ impl Analyzer {
);
}
Next::Fail => {
self.fail_question(job.id, e.message()).await?;
self.fail_question(job.id, job.started_at, e.message()).await?;
tracing::error!(id = %job.id, attempts = job.attempts, error = %e.message(), "answer failed");
}
}
@@ -174,14 +199,20 @@ impl Analyzer {
}
/// Marks the question failed and gives its unit back (once).
async fn fail_question(&self, id: Uuid, message: &str) -> Result<(), sqlx::Error> {
async fn fail_question(
&self,
id: Uuid,
started_at: time::OffsetDateTime,
message: &str,
) -> Result<(), sqlx::Error> {
let mut tx = self.db.begin().await?;
let row: Option<(Option<Uuid>, i32)> = sqlx::query_as(
"UPDATE questions SET status = 'failed', error = $2, completed_at = now() \
WHERE id = $1 AND status = 'running' RETURNING asked_by, credits_charged",
WHERE id = $1 AND status = 'running' AND started_at = $3 RETURNING asked_by, credits_charged",
)
.bind(id)
.bind(message)
.bind(started_at)
.fetch_optional(&mut *tx)
.await?;
if let Some((Some(user), units)) = row
+2 -1
View File
@@ -8,7 +8,7 @@ use tokio::sync::watch;
const INTERVAL: Duration = Duration::from_secs(3600);
/// (what, statement) pairs; each returns the number of deleted rows.
const STATEMENTS: [(&str, &str); 6] = [
const STATEMENTS: [(&str, &str); 7] = [
("sessions", "DELETE FROM sessions WHERE expires_at < now()"),
("auth_tokens", "DELETE FROM auth_tokens WHERE expires_at < now()"),
// Sent e-mails contain links with tokens; keep them a week for support.
@@ -26,6 +26,7 @@ const STATEMENTS: [(&str, &str); 6] = [
OR (accepted_at IS NOT NULL AND accepted_by IS NULL)",
),
("prompt_previews", "DELETE FROM prompt_previews WHERE created_at < now() - interval '30 days'"),
("generation_errors", "DELETE FROM generation_errors WHERE created_at < now() - interval '90 days'"),
];
pub async fn run_once(db: &PgPool) -> Result<Vec<(&'static str, u64)>, sqlx::Error> {
+99 -1
View File
@@ -212,7 +212,8 @@ async fn cleanup_removes_only_expired_data(db: PgPool) {
("emails", 1),
("invites", 0),
("invitations", 0),
("prompt_previews", 0)
("prompt_previews", 0),
("generation_errors", 0)
]
);
let (left,): (Vec<Uuid>,) =
@@ -533,6 +534,18 @@ mod analyses {
let (status, attempts, ..) = row(&db, id).await;
assert_eq!((status.as_str(), attempts), ("failed", 3));
assert_eq!(refunds(&db, s.user).await, vec![1]);
// every failed attempt is in the admin error log
let log: Vec<(String, i32, String, String)> = sqlx::query_as(
"SELECT source, attempt, outcome, model FROM generation_errors WHERE item_id = $1 ORDER BY id",
)
.bind(id)
.fetch_all(&db)
.await
.unwrap();
let expected = |attempt: i32, outcome: &str| {
("analysis".to_string(), attempt, outcome.to_string(), "test/model".to_string())
};
assert_eq!(log, vec![expected(1, "retry"), expected(2, "retry"), expected(3, "failed")]);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
@@ -780,5 +793,90 @@ mod analyses {
let models: Vec<String> =
fake.requests.lock().unwrap().iter().map(|b| b["model"].as_str().unwrap().to_string()).collect();
assert_eq!(models, ["cheap/model", "cheap/model", "test/model"]);
let outcomes: Vec<(String, String)> =
sqlx::query_as("SELECT outcome, model FROM generation_errors WHERE item_id = $1 ORDER BY id")
.bind(id)
.fetch_all(&db)
.await
.unwrap();
assert_eq!(
outcomes,
[("retry".to_string(), "cheap/model".to_string()), ("fallback".to_string(), "cheap/model".to_string())]
);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn a_restarted_attempt_does_not_write_its_result(db: PgPool) {
let s = setup(&db).await;
let id = request_analysis(&db, &s).await;
let (_, url) = fake_openrouter(vec![reply(&content(Kind::Natal))]).await;
let a = analyzer(&db, &url);
let job = a.claim().await.unwrap().expect("a job");
// an admin restarts it while the worker is still writing it
sqlx::query("UPDATE analyses SET status = 'pending', started_at = NULL, attempts = 0 WHERE id = $1")
.bind(id)
.execute(&db)
.await
.unwrap();
a.handle(job).await;
let (status, content): (String, Option<Value>) =
sqlx::query_as("SELECT status, content FROM analyses WHERE id = $1").bind(id).fetch_one(&db).await.unwrap();
assert_eq!((status.as_str(), content), ("pending", None));
// the new attempt writes it
assert!(run_once(&a).await);
let status: String =
sqlx::query_scalar("SELECT status FROM analyses WHERE id = $1").bind(id).fetch_one(&db).await.unwrap();
assert_eq!(status, "done");
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn answers_a_question_about_a_relationship_with_both_charts(db: PgPool) {
let s = setup(&db).await;
let response = fixture("synastry-response.json");
let (chart2, synastry, analysis) = (Uuid::now_v7(), Uuid::now_v7(), Uuid::now_v7());
sqlx::query(
"INSERT INTO charts (id, owner_id, label, is_primary, kind, birth_data, result, chart_hash) \
VALUES ($1, $2, 'Partner', false, 'person', '{}', $3, 'hash2')",
)
.bind(chart2)
.bind(s.user)
.bind(&response["person2"])
.execute(&db)
.await
.unwrap();
sqlx::query(
"INSERT INTO synastries (id, owner_id, chart1_id, chart2_id, result, synastry_hash) \
VALUES ($1, $2, $3, $4, $5, 'sh')",
)
.bind(synastry)
.bind(s.user)
.bind(s.chart)
.bind(chart2)
.bind(&response)
.execute(&db)
.await
.unwrap();
sqlx::query(
"INSERT INTO analyses (id, kind, synastry_id, requested_by, language, model, prompt_version, cache_key, \
status, content) VALUES ($1, 'synastry', $2, $3, 'hu', 'test/model', 'v1', 'k', 'done', $4)",
)
.bind(analysis)
.bind(synastry)
.bind(s.user)
.bind(content(Kind::Synastry))
.execute(&db)
.await
.unwrap();
let id = ask(&db, analysis, s.user, "Mire figyeljünk egy vitában?", "pending", None).await;
let (fake, url) = fake_openrouter(vec![reply(&json!({"answer": "Arra, hogy..."}))]).await;
let a = analyzer(&db, &url);
assert!(answer_once(&a).await);
let status: String =
sqlx::query_scalar("SELECT status FROM questions WHERE id = $1").bind(id).fetch_one(&db).await.unwrap();
assert_eq!(status, "done");
let requests = fake.requests.lock().unwrap();
let user = requests[0]["messages"][1]["content"].as_str().unwrap();
assert!(user.starts_with("Képletadatok:\n\nSYNASTRY") && user.contains("Person 2"), "both charts");
assert!(!user.contains("Szeged") && !user.contains("Pécs"));
}
}