Main #6

Merged
sagifer merged 4 commits from main into prod 2026-11-17 17:45:41 +01:00
13 changed files with 697 additions and 24 deletions
Showing only changes of commit b77dafdb26 - Show all commits
@@ -0,0 +1,29 @@
-- Test runs of an edited (not yet saved) system prompt on one of the admin's
-- charts. Kept apart from analyses: never shown to users, never cached, no
-- credits, one attempt. Removed after 30 days by the cleanup job.
CREATE TABLE prompt_previews (
id uuid PRIMARY KEY,
kind text NOT NULL CHECK (kind IN ('summary', 'natal')),
chart_id uuid NOT NULL REFERENCES charts ON DELETE CASCADE,
language text NOT NULL,
model text NOT NULL,
system text NOT NULL CHECK (length(system) BETWEEN 1 AND 50000),
status text NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'running', 'done', 'failed')),
content jsonb,
error text,
model_used text,
input_tokens integer,
output_tokens integer,
cost_usd double precision,
created_by uuid NOT NULL REFERENCES users ON DELETE CASCADE,
created_at timestamptz NOT NULL DEFAULT now(),
started_at timestamptz,
completed_at timestamptz
);
CREATE INDEX prompt_previews_pending_idx ON prompt_previews (created_at) WHERE status = 'pending';
-- Wakes the analysis worker, like a new analysis.
CREATE TRIGGER prompt_previews_notify
AFTER INSERT ON prompt_previews
FOR EACH STATEMENT EXECUTE FUNCTION notify_analyses();
+2
View File
@@ -79,6 +79,8 @@ Felhasználók, belépés, mentett születési képletek, szinasztriák és megh
| `POST /v1/admin/users/{id}/credits` | admin | `{unit: natal\|synastry, delta, note?}`: elemzések jóváírása vagy levonása | | `POST /v1/admin/users/{id}/credits` | admin | `{unit: natal\|synastry, delta, note?}`: elemzések jóváírása vagy levonása |
| `GET /v1/admin/prompts` | admin | a tömör és a részletes elemzés system promptja nyelvenként: érvényes szöveg, alapértelmezett, változatok | | `GET /v1/admin/prompts` | admin | a tömör és a részletes elemzés system promptja nyelvenként: érvényes szöveg, alapértelmezett, változatok |
| `PUT /v1/admin/prompts/{kind}/{language}` | admin | `{system}` új változatként menti (`null` vagy az alapértelmezett szöveg: vissza a beépítettre); az új elemzések `prompt_version`-je `v2-r<id>` | | `PUT /v1/admin/prompts/{kind}/{language}` | admin | `{system}` új változatként menti (`null` vagy az alapértelmezett szöveg: vissza a beépítettre); az új elemzések `prompt_version`-je `v2-r<id>` |
| `POST /v1/admin/prompts/{kind}/{language}/preview` | admin | `{system, chart_id}`: próbafuttatás a (mentetlen) szöveggel egy saját képleten; nem kerül a képlethez, nem gyorsítótárazott, nem fogy egység; egyszerre legfeljebb 3 |
| `GET /v1/admin/previews/{id}` | admin | a próbafuttatás állapota és eredménye (modell, token, költség) |
Hibák formátuma: `{"error": {"code", "message"}}`. A születési adatok hibái (például ismeretlen hely, javaslatokkal együtt) változatlanul jönnek tovább a horoscope-api-ból. Hibák formátuma: `{"error": {"code", "message"}}`. A születési adatok hibái (például ismeretlen hely, javaslatokkal együtt) változatlanul jönnek tovább a horoscope-api-ból.
+2
View File
@@ -92,6 +92,8 @@ pub fn router(state: Arc<AppState>) -> Router {
.route("/v1/admin/users/{id}/credits", post(admin::adjust_credits)) .route("/v1/admin/users/{id}/credits", post(admin::adjust_credits))
.route("/v1/admin/prompts", get(prompts::list)) .route("/v1/admin/prompts", get(prompts::list))
.route("/v1/admin/prompts/{kind}/{language}", axum::routing::put(prompts::save)) .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))
.layer(cors(&state.config.cors_allowed_origins)) .layer(cors(&state.config.cors_allowed_origins))
.layer( .layer(
TraceLayer::new_for_http() TraceLayer::new_for_http()
+139 -7
View File
@@ -4,26 +4,34 @@
//! (kind, language) is in force, `system` NULL meaning the built-in text. //! (kind, language) is in force, `system` NULL meaning the built-in text.
//! New analyses record the revision in `prompt_version`, so analyses that //! New analyses record the revision in `prompt_version`, so analyses that
//! are already written or queued keep the text they were started with. //! are already written or queued keep the text they were started with.
//!
//! A draft can be tried on one of the admin's own charts first: a row in
//! `prompt_previews` that the worker writes like an analysis, but it is never
//! shown to users, cached or charged.
use analysis_prompt::{Kind, default_system, user_template}; use analysis_prompt::{Kind, default_system, user_template};
use axum::Json; use axum::Json;
use axum::extract::{Path, State}; use axum::extract::{Path, State};
use axum::http::StatusCode;
use axum_extra::extract::WithRejection; use axum_extra::extract::WithRejection;
use serde::Deserialize; use serde::Deserialize;
use serde_json::{Value, json}; use serde_json::{Value, json};
use sqlx::PgPool; use sqlx::PgPool;
use time::OffsetDateTime; use time::OffsetDateTime;
use uuid::Uuid;
use super::{Body, St}; use super::{Body, IdPath, St};
use crate::AppState; use crate::AppState;
use crate::auth::AdminUser; use crate::auth::AdminUser;
use crate::error::{ApiError, ApiResult}; use crate::error::{ApiError, ApiResult};
use crate::views::rfc3339; use crate::views::{rfc3339, rfc3339_opt};
/// The kinds whose prompt the admin page edits. /// The kinds whose prompt the admin page edits.
const EDITABLE: [Kind; 2] = [Kind::Summary, Kind::Natal]; const EDITABLE: [Kind; 2] = [Kind::Summary, Kind::Natal];
const MAX_CHARS: usize = 50_000; const MAX_CHARS: usize = 50_000;
const HISTORY: i64 = 20; const HISTORY: i64 = 20;
/// Test runs of one admin waiting or being written at the same time.
const MAX_OPEN_PREVIEWS: i64 = 3;
/// The revision id of an admin-edited prompt in force, `None` for the built-in one. /// The revision id of an admin-edited prompt in force, `None` for the built-in one.
pub async fn current_revision(db: &PgPool, kind: &str, language: &str) -> Result<Option<i64>, sqlx::Error> { pub async fn current_revision(db: &PgPool, kind: &str, language: &str) -> Result<Option<i64>, sqlx::Error> {
@@ -96,6 +104,18 @@ fn parse_target(state: &AppState, kind: &str, language: &str) -> Result<Kind, Ap
Ok(kind) Ok(kind)
} }
/// Trims a submitted prompt and checks its length.
fn clean_system(text: &str) -> Result<String, ApiError> {
let text = text.trim().replace("\r\n", "\n");
if text.is_empty() {
return Err(ApiError::BadRequest("the prompt must not be empty".into()));
}
if text.chars().count() > MAX_CHARS {
return Err(ApiError::BadRequest(format!("the prompt is longer than {MAX_CHARS} characters")));
}
Ok(text)
}
pub async fn save( pub async fn save(
State(state): St, State(state): St,
AdminUser(admin): AdminUser, AdminUser(admin): AdminUser,
@@ -105,11 +125,7 @@ pub async fn save(
let kind = parse_target(&state, &kind, &language)?; let kind = parse_target(&state, &kind, &language)?;
let default = default_system(kind, &language); let default = default_system(kind, &language);
// The built-in text is stored as NULL, so later code changes reach it. // The built-in text is stored as NULL, so later code changes reach it.
let system = match req.system.map(|s| s.trim().replace("\r\n", "\n")) { let system = match req.system.as_deref().map(clean_system).transpose()? {
Some(s) if s.is_empty() => return Err(ApiError::BadRequest("the prompt must not be empty".into())),
Some(s) if s.chars().count() > MAX_CHARS => {
return Err(ApiError::BadRequest(format!("the prompt is longer than {MAX_CHARS} characters")));
}
Some(s) if s == default.trim() => None, Some(s) if s == default.trim() => None,
other => other, other => other,
}; };
@@ -136,3 +152,119 @@ pub async fn save(
} }
Ok(Json(entry(&state.db, kind, &language).await?)) Ok(Json(entry(&state.db, kind, &language).await?))
} }
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct StartPreview {
/// The draft to try (it need not be saved).
system: String,
/// One of the admin's own charts (own or a person).
chart_id: Uuid,
}
type PreviewRow = (
Uuid,
String,
Uuid,
String,
String,
String,
Option<Value>,
Option<String>,
Option<String>,
Option<i32>,
Option<i32>,
Option<f64>,
OffsetDateTime,
Option<OffsetDateTime>,
Option<OffsetDateTime>,
);
const PREVIEW_COLUMNS: &str = "id, kind, chart_id, language, model, status, content, error, model_used, \
input_tokens, output_tokens, cost_usd, created_at, started_at, completed_at";
fn preview_view(row: PreviewRow) -> Value {
let (
id,
kind,
chart_id,
language,
model,
status,
content,
error,
model_used,
input,
output,
cost,
created,
started,
completed,
) = row;
let seconds = started.zip(completed).map(|(s, c)| (c - s).whole_seconds());
json!({
"id": id, "kind": kind, "chart_id": chart_id, "language": language, "model": model, "status": status,
"content": content, "error": error, "model_used": model_used, "input_tokens": input, "output_tokens": output,
"cost_usd": cost, "created_at": rfc3339(created), "completed_at": rfc3339_opt(completed), "seconds": seconds,
})
}
pub async fn start_preview(
State(state): St,
AdminUser(admin): AdminUser,
WithRejection(Path((kind, language)), _): WithRejection<Path<(String, String)>, ApiError>,
WithRejection(Json(req), _): Body<StartPreview>,
) -> ApiResult<(StatusCode, Json<Value>)> {
let kind = parse_target(&state, &kind, &language)?;
let system = clean_system(&req.system)?;
let own: Option<(Uuid,)> = sqlx::query_as("SELECT id FROM charts WHERE id = $1 AND owner_id = $2")
.bind(req.chart_id)
.bind(admin.id())
.fetch_optional(&state.db)
.await?;
own.ok_or(ApiError::NotFound("chart"))?;
let (open,): (i64,) = sqlx::query_as(
"SELECT count(*) FROM prompt_previews WHERE created_by = $1 AND status IN ('pending', 'running')",
)
.bind(admin.id())
.fetch_one(&state.db)
.await?;
if open >= MAX_OPEN_PREVIEWS {
return Err(ApiError::conflict(
"too_many_previews",
"Egyszerre legfeljebb három próba futhat. Várd meg, amíg valamelyik elkészül.",
));
}
let model = match kind {
Kind::Summary => &state.config.summary_model,
_ => &state.config.analysis_model,
};
let row: PreviewRow = sqlx::query_as(&format!(
"INSERT INTO prompt_previews (id, kind, chart_id, language, model, system, created_by) \
VALUES ($1, $2, $3, $4, $5, $6, $7) RETURNING {PREVIEW_COLUMNS}"
))
.bind(Uuid::now_v7())
.bind(kind.as_str())
.bind(req.chart_id)
.bind(&language)
.bind(model)
.bind(&system)
.bind(admin.id())
.fetch_one(&state.db)
.await?;
Ok((StatusCode::ACCEPTED, Json(preview_view(row))))
}
pub async fn get_preview(
State(state): St,
AdminUser(admin): AdminUser,
WithRejection(Path(id), _): IdPath,
) -> ApiResult<Json<Value>> {
let row: Option<PreviewRow> =
sqlx::query_as(&format!("SELECT {PREVIEW_COLUMNS} FROM prompt_previews WHERE id = $1 AND created_by = $2"))
.bind(id)
.bind(admin.id())
.fetch_optional(&state.db)
.await?;
Ok(Json(preview_view(row.ok_or(ApiError::NotFound("preview"))?)))
}
+52
View File
@@ -894,3 +894,55 @@ async fn admins_edit_analysis_prompts(pool: PgPool) {
assert_eq!((&r.body["custom"], r.body["system"].as_str()), (&json!(false), Some(default.as_str()))); assert_eq!((&r.body["custom"], r.body["system"].as_str()), (&json!(false), Some(default.as_str())));
assert_eq!(r.body["history"].as_array().unwrap().len(), 2); assert_eq!(r.body["history"].as_array().unwrap().len(), 2);
} }
/// Starts a summary prompt test run on `chart`.
async fn start_preview(app: &TestApp, chart: &Value, token: &str) -> Response {
let body = json!({"system": " Próba szabályok. ", "chart_id": chart["id"]});
app.call("POST", "/v1/admin/prompts/summary/hu/preview", Some(token), Some(body)).await
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn admins_try_prompt_drafts_on_own_charts(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 own = app.chart(&admin, "Saját", true, "1990-03-15").await;
let annas = app.chart(&anna, "Saját", true, "1991-05-01").await;
assert_eq!(start_preview(&app, &own, &anna).await.status, StatusCode::FORBIDDEN);
assert_eq!(start_preview(&app, &annas, &admin).await.status, StatusCode::NOT_FOUND); // only own charts
let r = start_preview(&app, &own, &admin).await;
assert_eq!(r.status, StatusCode::ACCEPTED, "{}", r.body);
assert_eq!(
(r.body["status"].as_str(), r.body["kind"].as_str(), r.body["model"].as_str()),
(Some("pending"), Some("summary"), Some("anthropic/claude-summary"))
);
let id = r.body["id"].as_str().unwrap().to_string();
let (system,): (String,) = sqlx::query_as("SELECT system FROM prompt_previews WHERE id = $1::uuid")
.bind(&id)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(system, "Próba szabályok.");
// nothing reaches the chart's analyses, and the saved prompt is unchanged
let r = app.get(&format!("/v1/charts/{}/analyses", own["id"].as_str().unwrap()), Some(&admin)).await;
assert!(
r.body["analyses"].as_array().unwrap().iter().all(|a| a["kind"] == "summary" && a["prompt_version"] == "v1")
);
assert_eq!(app.get("/v1/admin/prompts", Some(&admin)).await.body["prompts"][0]["custom"], json!(false));
let r = app.get(&format!("/v1/admin/previews/{id}"), Some(&admin)).await;
assert_eq!((r.status, r.body["status"].as_str()), (StatusCode::OK, Some("pending")));
assert_eq!(app.get(&format!("/v1/admin/previews/{id}"), Some(&anna)).await.status, StatusCode::FORBIDDEN);
// at most three at a time
start_preview(&app, &own, &admin).await;
start_preview(&app, &own, &admin).await;
let r = start_preview(&app, &own, &admin).await;
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("too_many_previews")));
let body = json!({"system": "Részletes próba.", "chart_id": own["id"]});
sqlx::query("UPDATE prompt_previews SET status = 'done'").execute(&pool).await.unwrap();
let r = app.call("POST", "/v1/admin/prompts/natal/hu/preview", Some(&admin), Some(body)).await;
assert_eq!((r.status, r.body["model"].as_str()), (StatusCode::ACCEPTED, Some("anthropic/claude-test")));
}
@@ -5,7 +5,9 @@ import { useEffect, useState } from "react";
import { Tabs } from "@/components/Tabs"; import { Tabs } from "@/components/Tabs";
import { api, errorText } from "@/lib/api"; import { api, errorText } from "@/lib/api";
import { formatDate } from "@/lib/astro"; import { formatDate } from "@/lib/astro";
import type { AdminPrompt, PromptKind } from "@/lib/types"; import type { AdminPrompt, ChartListItem, PromptKind } from "@/lib/types";
import { PromptTrial } from "./PromptTrial";
const KINDS: { kind: PromptKind; id: string; label: string; about: string }[] = [ const KINDS: { kind: PromptKind; id: string; label: string; about: string }[] = [
{ {
@@ -26,12 +28,16 @@ const LANGUAGES: Record<string, string> = { hu: "Magyar", en: "Angol" };
export function AdminPrompts() { export function AdminPrompts() {
const [prompts, setPrompts] = useState<AdminPrompt[] | null>(null); const [prompts, setPrompts] = useState<AdminPrompt[] | null>(null);
const [charts, setCharts] = useState<ChartListItem[]>([]);
const [error, setError] = useState<string | null>(null); const [error, setError] = useState<string | null>(null);
useEffect(() => { useEffect(() => {
api<{ prompts: AdminPrompt[] }>("/admin/prompts") api<{ prompts: AdminPrompt[] }>("/admin/prompts")
.then((d) => setPrompts(d.prompts)) .then((d) => setPrompts(d.prompts))
.catch((e) => setError(errorText(e))); .catch((e) => setError(errorText(e)));
api<{ charts: ChartListItem[] }>("/charts")
.then((d) => setCharts(d.charts))
.catch(() => setCharts([]));
}, []); }, []);
if (error) { if (error) {
@@ -54,7 +60,12 @@ export function AdminPrompts() {
id: k.id, id: k.id,
label: k.label, label: k.label,
content: ( content: (
<KindPrompts about={k.about} prompts={prompts.filter((p) => p.kind === k.kind)} onSaved={replace} /> <KindPrompts
about={k.about}
prompts={prompts.filter((p) => p.kind === k.kind)}
charts={charts}
onSaved={replace}
/>
), ),
}))} }))}
/> />
@@ -65,10 +76,12 @@ export function AdminPrompts() {
function KindPrompts({ function KindPrompts({
about, about,
prompts, prompts,
charts,
onSaved, onSaved,
}: { }: {
about: string; about: string;
prompts: AdminPrompt[]; prompts: AdminPrompt[];
charts: ChartListItem[];
onSaved: (p: AdminPrompt) => void; onSaved: (p: AdminPrompt) => void;
}) { }) {
const [language, setLanguage] = useState(prompts[0]?.language ?? "hu"); const [language, setLanguage] = useState(prompts[0]?.language ?? "hu");
@@ -97,12 +110,20 @@ function KindPrompts({
</div> </div>
)} )}
</div> </div>
<PromptEditor key={`${prompt.kind}-${prompt.language}`} prompt={prompt} onSaved={onSaved} /> <PromptEditor key={`${prompt.kind}-${prompt.language}`} prompt={prompt} charts={charts} onSaved={onSaved} />
</div> </div>
); );
} }
function PromptEditor({ prompt, onSaved }: { prompt: AdminPrompt; onSaved: (p: AdminPrompt) => void }) { function PromptEditor({
prompt,
charts,
onSaved,
}: {
prompt: AdminPrompt;
charts: ChartListItem[];
onSaved: (p: AdminPrompt) => void;
}) {
const [draft, setDraft] = useState(prompt.system); const [draft, setDraft] = useState(prompt.system);
const [busy, setBusy] = useState(false); const [busy, setBusy] = useState(false);
const [error, setError] = useState<string | null>(null); const [error, setError] = useState<string | null>(null);
@@ -201,6 +222,17 @@ function PromptEditor({ prompt, onSaved }: { prompt: AdminPrompt; onSaved: (p: A
)} )}
</div> </div>
<PromptTrial
kind={prompt.kind}
language={prompt.language}
draft={draft}
charts={charts}
onLoad={(system) => {
setDraft(system);
setSaved(false);
}}
/>
<details className="details"> <details className="details">
<summary>Amit a modell ezen felül kap</summary> <summary>Amit a modell ezen felül kap</summary>
<div className="prompt-extra"> <div className="prompt-extra">
@@ -0,0 +1,195 @@
"use client";
import { useCallback, useEffect, useState } from "react";
import { AnalysisLoading } from "@/components/AnalysisLoading";
import { AnalysisView } from "@/components/AnalysisView";
import { api, errorText } from "@/lib/api";
import { formatDate } from "@/lib/astro";
import type { ChartListItem, PromptKind, PromptPreview } from "@/lib/types";
const POLL_MS = 4000;
const MAX_POLLS = 150; // 10 minutes
interface Trial {
preview: PromptPreview;
/** The draft it was written with, to load it back. */
system: string;
}
/**
* Writes an analysis with the draft in the editor (saved or not) on one of
* the admin's charts. Nothing is stored with the chart.
*/
export function PromptTrial({
kind,
language,
draft,
charts,
onLoad,
}: {
kind: PromptKind;
language: string;
draft: string;
charts: ChartListItem[];
onLoad: (system: string) => void;
}) {
const [chartId, setChartId] = useState(charts.find((c) => c.is_primary)?.id ?? charts[0]?.id ?? "");
const [trials, setTrials] = useState<Trial[]>([]);
const [busy, setBusy] = useState(false);
const [error, setError] = useState<string | null>(null);
const selectId = `trial-chart-${kind}-${language}`;
async function start() {
setBusy(true);
setError(null);
try {
const preview = await api<PromptPreview>(`/admin/prompts/${kind}/${language}/preview`, {
body: { system: draft, chart_id: chartId },
});
setTrials((all) => [{ preview, system: draft }, ...all]);
} catch (e) {
setError(errorText(e));
} finally {
setBusy(false);
}
}
const update = useCallback(
(next: PromptPreview) =>
setTrials((all) => all.map((t) => (t.preview.id === next.id ? { ...t, preview: next } : t))),
[],
);
return (
<section className="prompt-trial" aria-labelledby={`${selectId}-title`}>
<div className="prompt-trial-head">
<h2 id={`${selectId}-title`}>Kipróbálás</h2>
<p className="hint">
A szerkesztőben lévő szöveggel (mentés nélkül is) megírja az elemzést egy saját képletedre. Az eredmény nem
kerül a képlethez, csak itt látod. Valódi modellhívás, ezért költsége van.
</p>
</div>
{charts.length === 0 ? (
<p className="muted">Kipróbáláshoz előbb legyen legalább egy képleted.</p>
) : (
<div className="prompt-trial-form">
<div className="field">
<label htmlFor={selectId}>Képlet</label>
<select id={selectId} className="inp" value={chartId} onChange={(e) => setChartId(e.target.value)}>
{charts.map((c) => (
<option key={c.id} value={c.id}>
{c.is_primary ? `Én (${c.label})` : c.label}
{c.birth.time ? "" : " – idő nélkül"}
</option>
))}
</select>
</div>
<button type="button" className="btn btn-primary" onClick={start} disabled={busy || !chartId || !draft.trim()}>
{busy ? "Indítás…" : "Kipróbálás"}
</button>
</div>
)}
{error && (
<p className="msg msg-error" role="alert">
{error}
</p>
)}
{trials.map((t) => (
<TrialResult
key={t.preview.id}
trial={t}
chartLabel={charts.find((c) => c.id === t.preview.chart_id)?.label ?? "Képlet"}
changed={t.system.trim() !== draft.trim()}
onUpdate={update}
onLoad={() => onLoad(t.system)}
/>
))}
</section>
);
}
function TrialResult({
trial,
chartLabel,
changed,
onUpdate,
onLoad,
}: {
trial: Trial;
chartLabel: string;
changed: boolean;
onUpdate: (p: PromptPreview) => void;
onLoad: () => void;
}) {
const p = trial.preview;
const waiting = p.status === "pending" || p.status === "running";
useEffect(() => {
if (!waiting) return;
let polls = 0;
let stopped = false;
let timer: ReturnType<typeof setTimeout> | undefined;
const tick = async () => {
try {
const next = await api<PromptPreview>(`/admin/previews/${p.id}`);
if (stopped) return;
onUpdate(next);
if (next.status === "done" || next.status === "failed") return;
} catch {
// try again on the next tick
}
if (++polls < MAX_POLLS) timer = setTimeout(tick, POLL_MS);
};
timer = setTimeout(tick, POLL_MS);
return () => {
stopped = true;
clearTimeout(timer);
};
}, [waiting, p.id, onUpdate]);
const meta = [
p.model_used ?? p.model,
p.seconds !== null ? `${p.seconds} mp` : null,
p.input_tokens !== null && p.output_tokens !== null
? `${p.input_tokens.toLocaleString("hu-HU")} + ${p.output_tokens.toLocaleString("hu-HU")} token`
: null,
p.cost_usd !== null ? `$${p.cost_usd.toFixed(4)}` : null,
].filter(Boolean);
return (
<article className="trial" aria-busy={waiting}>
<header className="trial-head">
<div>
<strong>{chartLabel}</strong>
<span className="hint"> · {formatDate(p.created_at, true)}</span>
</div>
{changed && (
<button type="button" className="btn btn-sm" onClick={onLoad}>
Ennek a szövegnek a betöltése
</button>
)}
</header>
{waiting ? (
<AnalysisLoading
compact
text={p.kind === "summary" ? "Készül az összefoglaló, kb. 10–30 másodperc." : "Készül az elemzés, kb. 1–3 perc."}
/>
) : p.status === "failed" ? (
<p className="msg msg-error" role="alert">
Nem sikerült: {p.error ?? "ismeretlen hiba"}
</p>
) : p.content ? (
p.kind === "summary" ? (
<div className="trial-summary">
<h3 className="summary-title">{p.content.title}</h3>
<p className="summary-text">{p.content.summary}</p>
</div>
) : (
<AnalysisView content={p.content} />
)
) : null}
{meta.length > 0 && !waiting && <p className="hint">{meta.join(" · ")}</p>}
</article>
);
}
+18
View File
@@ -441,3 +441,21 @@ td.num { font-variant-numeric: tabular-nums; white-space: nowrap; }
.prompt-history li .hint { grid-column: 1; } .prompt-history li .hint { grid-column: 1; }
.prompt-history li .btn { grid-column: 2; grid-row: 1 / span 2; } .prompt-history li .btn { grid-column: 2; grid-row: 1 / span 2; }
} }
.prompt-trial {
display: flex; flex-direction: column; gap: 16px; padding: 20px; border: 1px solid var(--line);
border-radius: var(--radius); background: rgba(255, 255, 255, 0.015);
}
.prompt-trial-head { display: flex; flex-direction: column; gap: 6px; }
.prompt-trial-head h2 { font-size: 18px; margin: 0; }
.prompt-trial-head .hint { margin: 0; }
.prompt-trial-form { display: flex; gap: 12px; align-items: flex-end; flex-wrap: wrap; }
.prompt-trial-form .field { flex: 0 1 360px; }
.trial { display: flex; flex-direction: column; gap: 14px; padding-top: 16px; border-top: 1px solid var(--line); }
.trial-head { display: flex; gap: 8px 12px; align-items: center; justify-content: space-between; flex-wrap: wrap; }
.trial-summary { display: flex; flex-direction: column; gap: 8px; }
.trial-summary .summary-title, .trial-summary .summary-text { margin: 0; }
@media (max-width: 640px) {
.prompt-trial { padding: 16px; }
.prompt-trial-form .field { flex-basis: 100%; }
.prompt-trial-form .btn { width: 100%; }
}
+19
View File
@@ -175,6 +175,25 @@ export interface AdminPrompt {
history: PromptRevision[]; history: PromptRevision[];
} }
/** A test run of a draft prompt on one of the admin's charts. */
export interface PromptPreview {
id: string;
kind: PromptKind;
chart_id: string;
language: string;
model: string;
status: "pending" | "running" | "done" | "failed";
content: AnalysisContent | null;
error: string | null;
model_used: string | null;
input_tokens: number | null;
output_tokens: number | null;
cost_usd: number | null;
created_at: string;
completed_at: string | null;
seconds: number | null;
}
export interface AnalysisContent { export interface AnalysisContent {
title?: string; title?: string;
summary?: string; summary?: string;
+1
View File
@@ -27,6 +27,7 @@ Háttérmunkák a közös PostgreSQL-adatbázis fölött: e-mail-küldés, szöv
- a rövid összefoglalónál (`summary`) csak `title` és egy 3–4 mondatos `summary`. - a rövid összefoglalónál (`summary`) csak `title` és egy 3–4 mondatos `summary`.
A worker a választ maga is ellenőrzi a sémán. Magyar szövegben az egyenes idézőjelpárokat („…”) alakra cseréli. A worker a választ maga is ellenőrzi a sémán. Magyar szövegben az egyenes idézőjelpárokat („…”) alakra cseréli.
- Ha nincs esedékes elemzés, a worker az admin próbafuttatásait írja (`prompt_previews`): a mentetlen system prompttal, egyetlen próbálkozással, egység nélkül. 30 nap után a takarítás törli őket.
- Eltárolja a ténylegesen válaszoló modellt (`model_used`; az `openrouter/auto` mögött ez más lehet), a tokenszámot és a költséget (`cost_usd`). - Eltárolja a ténylegesen válaszoló modellt (`model_used`; az `openrouter/auto` mögött ez más lehet), a tokenszámot és a költséget (`cost_usd`).
- **Átmeneti hiba** (hálózat, 429, 5xx, elfogyott OpenRouter-egyenleg, hibás vagy csonka válasz): újrapróbálja 30 mp, 2 perc, majd 8 perc múlva. - **Átmeneti hiba** (hálózat, 429, 5xx, elfogyott OpenRouter-egyenleg, hibás vagy csonka válasz): újrapróbálja 30 mp, 2 perc, majd 8 perc múlva.
- **Végleges hiba** (például ismeretlen modell), vagy ha elfogyott a `MAX_ANALYSIS_ATTEMPTS` próbálkozás: az elemzés `failed` lesz, és az egység visszajár (`refund`, elemzésenként legfeljebb egyszer). - **Végleges hiba** (például ismeretlen modell), vagy ha elfogyott a `MAX_ANALYSIS_ATTEMPTS` próbálkozás: az elemzés `failed` lesz, és az egység visszajár (`refund`, elemzésenként legfeljebb egyszer).
+126 -11
View File
@@ -5,6 +5,9 @@
//! through OpenRouter and stores the structured answer (`done`). Temporary //! through OpenRouter and stores the structured answer (`done`). Temporary
//! failures are retried with backoff; after the last attempt, or on a //! failures are retried with backoff; after the last attempt, or on a
//! permanent error, the analysis is `failed` and the unit is refunded. //! permanent error, the analysis is `failed` and the unit is refunded.
//!
//! Admin test runs of an edited prompt (`prompt_previews`) go through the
//! same loop when no analysis is due: one attempt, no credits, no retries.
pub mod compact; pub mod compact;
pub mod openrouter; pub mod openrouter;
@@ -37,12 +40,23 @@ pub struct Job {
pub attempts: i32, pub attempts: i32,
} }
/// A test run of an edited system prompt on a chart.
#[derive(Debug, sqlx::FromRow)]
pub struct PreviewJob {
pub id: Uuid,
pub kind: String,
pub chart_id: Uuid,
pub language: String,
pub model: String,
pub system: String,
}
pub struct Analyzer { pub struct Analyzer {
pub db: PgPool, pub db: PgPool,
pub llm: OpenRouter, pub llm: OpenRouter,
pub max_attempts: i32, pub max_attempts: i32,
pub concurrency: usize, pub concurrency: usize,
/// Analyses being written right now (put back to `pending` on shutdown). /// Analyses and previews being written right now (released on shutdown).
running: Mutex<HashSet<Uuid>>, running: Mutex<HashSet<Uuid>>,
} }
@@ -79,15 +93,7 @@ impl Analyzer {
let db_err = |e: sqlx::Error| LlmError::Transient(format!("database: {e}")); let db_err = |e: sqlx::Error| LlmError::Transient(format!("database: {e}"));
let gone = || LlmError::Permanent("the chart was deleted".into()); let gone = || LlmError::Permanent("the chart was deleted".into());
let text = match kind { let text = match kind {
Kind::Natal | Kind::Summary => { Kind::Natal | Kind::Summary => self.natal_text(job.chart_id).await?,
let (chart,): (Value,) = sqlx::query_as("SELECT result FROM charts WHERE id = $1")
.bind(job.chart_id)
.fetch_optional(&self.db)
.await
.map_err(db_err)?
.ok_or_else(gone)?;
compact::natal(&chart)
}
Kind::Synastry => { Kind::Synastry => {
let (result, chart1, chart2): (Value, Value, Value) = sqlx::query_as( let (result, chart1, chart2): (Value, Value, Value) = sqlx::query_as(
"SELECT s.result, c1.result, c2.result FROM synastries s \ "SELECT s.result, c1.result, c2.result FROM synastries s \
@@ -118,6 +124,83 @@ impl Analyzer {
Ok(prompt::build(kind, &job.language, &text, system.as_deref())) Ok(prompt::build(kind, &job.language, &text, system.as_deref()))
} }
/// The compact text of a stored natal chart.
async fn natal_text(&self, chart_id: Option<Uuid>) -> Result<String, LlmError> {
let (chart,): (Value,) = sqlx::query_as("SELECT result FROM charts WHERE id = $1")
.bind(chart_id)
.fetch_optional(&self.db)
.await
.map_err(|e| LlmError::Transient(format!("database: {e}")))?
.ok_or_else(|| LlmError::Permanent("the chart was deleted".into()))?;
Ok(compact::natal(&chart))
}
/// Takes the oldest waiting prompt test run, if any.
pub async fn claim_preview(&self) -> Result<Option<PreviewJob>, sqlx::Error> {
let job: Option<PreviewJob> = sqlx::query_as(
"UPDATE prompt_previews SET status = 'running', started_at = now() \
WHERE id = (SELECT id FROM prompt_previews WHERE status = 'pending' \
ORDER BY created_at LIMIT 1 FOR UPDATE SKIP LOCKED) \
RETURNING id, kind, chart_id, language, model, system",
)
.fetch_optional(&self.db)
.await?;
if let Some(job) = &job {
self.running.lock().unwrap().insert(job.id);
}
Ok(job)
}
/// Writes one test run with the edited system prompt (a single attempt).
pub async fn handle_preview(&self, job: PreviewJob) {
let started = Instant::now();
let result = async {
let kind = Kind::parse(&job.kind)
.filter(|k| *k != Kind::Synastry)
.ok_or_else(|| LlmError::Permanent(format!("unknown kind '{}'", job.kind)))?;
let text = self.natal_text(Some(job.chart_id)).await?;
let built = prompt::build(kind, &job.language, &text, Some(&job.system));
let mut c = self.llm.complete(&job.model, &built).await?;
prompt::polish(&job.language, &mut c.content);
Ok::<_, LlmError>(c)
}
.await;
let saved = match &result {
Ok(c) => {
sqlx::query(
"UPDATE prompt_previews SET status = 'done', content = $2, model_used = $3, input_tokens = $4, \
output_tokens = $5, cost_usd = $6, completed_at = now() WHERE id = $1 AND status = 'running'",
)
.bind(job.id)
.bind(&c.content)
.bind(&c.model)
.bind(c.input_tokens)
.bind(c.output_tokens)
.bind(c.cost_usd)
.execute(&self.db)
.await
}
Err(e) => {
sqlx::query(
"UPDATE prompt_previews SET status = 'failed', error = $2, completed_at = now() \
WHERE id = $1 AND status = 'running'",
)
.bind(job.id)
.bind(e.message())
.execute(&self.db)
.await
}
};
match (&result, saved) {
(_, Err(e)) => tracing::error!(id = %job.id, error = %e, "saving the prompt preview failed"),
(Ok(c), Ok(_)) => tracing::info!(
id = %job.id, model = %c.model, cost_usd = c.cost_usd, secs = started.elapsed().as_secs(), "prompt preview done"
),
(Err(e), Ok(_)) => tracing::warn!(id = %job.id, error = %e.message(), "prompt preview failed"),
}
self.running.lock().unwrap().remove(&job.id);
}
/// Writes one claimed analysis and records the outcome. /// Writes one claimed analysis and records the outcome.
pub async fn handle(&self, job: Job) { pub async fn handle(&self, job: Job) {
let started = Instant::now(); let started = Instant::now();
@@ -215,6 +298,14 @@ impl Analyzer {
.bind(STUCK_AFTER_MINUTES) .bind(STUCK_AFTER_MINUTES)
.execute(&self.db) .execute(&self.db)
.await?; .await?;
// A test run is not retried: the admin can start it again.
sqlx::query(
"UPDATE prompt_previews SET status = 'failed', error = 'interrupted', completed_at = now() \
WHERE status = 'running' AND started_at < now() - make_interval(mins => $1)",
)
.bind(STUCK_AFTER_MINUTES)
.execute(&self.db)
.await?;
Ok(result.rows_affected()) Ok(result.rows_affected())
} }
@@ -235,6 +326,16 @@ impl Analyzer {
Ok(r) => tracing::info!(released = r.rows_affected(), "unfinished analyses put back in the queue"), Ok(r) => tracing::info!(released = r.rows_affected(), "unfinished analyses put back in the queue"),
Err(e) => tracing::error!(error = %e, "releasing unfinished analyses"), Err(e) => tracing::error!(error = %e, "releasing unfinished analyses"),
} }
let result = sqlx::query(
"UPDATE prompt_previews SET status = 'failed', error = 'interrupted', completed_at = now() \
WHERE id = ANY($1) AND status = 'running'",
)
.bind(&ids)
.execute(&self.db)
.await;
if let Err(e) = result {
tracing::error!(error = %e, "releasing unfinished prompt previews");
}
} }
} }
@@ -265,7 +366,21 @@ pub async fn run(analyzer: Arc<Analyzer>, poll: Duration, stop: watch::Receiver<
drop(permit); drop(permit);
}); });
} }
Ok(None) => break, // No analysis is due: a prompt test run, if one waits.
Ok(None) => match analyzer.claim_preview().await {
Ok(Some(job)) => {
let analyzer = analyzer.clone();
tasks.spawn(async move {
analyzer.handle_preview(job).await;
drop(permit);
});
}
Ok(None) => break,
Err(e) => {
tracing::error!(error = %e, "claiming a prompt preview");
break;
}
},
Err(e) => { Err(e) => {
tracing::error!(error = %e, "claiming an analysis"); tracing::error!(error = %e, "claiming an analysis");
break; break;
+2 -1
View File
@@ -8,7 +8,7 @@ use tokio::sync::watch;
const INTERVAL: Duration = Duration::from_secs(3600); const INTERVAL: Duration = Duration::from_secs(3600);
/// (what, statement) pairs; each returns the number of deleted rows. /// (what, statement) pairs; each returns the number of deleted rows.
const STATEMENTS: [(&str, &str); 4] = [ const STATEMENTS: [(&str, &str); 5] = [
("sessions", "DELETE FROM sessions WHERE expires_at < now()"), ("sessions", "DELETE FROM sessions WHERE expires_at < now()"),
("auth_tokens", "DELETE FROM auth_tokens 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. // Sent e-mails contain links with tokens; keep them a week for support.
@@ -18,6 +18,7 @@ const STATEMENTS: [(&str, &str); 4] = [
OR failed_at < now() - interval '30 days'", OR failed_at < now() - interval '30 days'",
), ),
("invites", "DELETE FROM synastry_invites WHERE accepted_at IS NULL AND expires_at < now() - interval '30 days'"), ("invites", "DELETE FROM synastry_invites WHERE accepted_at IS NULL AND expires_at < now() - interval '30 days'"),
("prompt_previews", "DELETE FROM prompt_previews WHERE created_at < now() - interval '30 days'"),
]; ];
pub async fn run_once(db: &PgPool) -> Result<Vec<(&'static str, u64)>, sqlx::Error> { pub async fn run_once(db: &PgPool) -> Result<Vec<(&'static str, u64)>, sqlx::Error> {
+76 -1
View File
@@ -175,7 +175,10 @@ async fn cleanup_removes_only_expired_data(db: PgPool) {
sqlx::query("UPDATE email_outbox SET sent_at = now() WHERE id = $1").bind(recent).execute(&db).await.unwrap(); sqlx::query("UPDATE email_outbox SET sent_at = now() WHERE id = $1").bind(recent).execute(&db).await.unwrap();
let deleted = crate::cleanup::run_once(&db).await.unwrap(); let deleted = crate::cleanup::run_once(&db).await.unwrap();
assert_eq!(deleted, vec![("sessions", 1), ("auth_tokens", 0), ("emails", 1), ("invites", 0)]); assert_eq!(
deleted,
vec![("sessions", 1), ("auth_tokens", 0), ("emails", 1), ("invites", 0), ("prompt_previews", 0)]
);
let (left,): (Vec<Uuid>,) = let (left,): (Vec<Uuid>,) =
sqlx::query_as("SELECT array_agg(id ORDER BY id) FROM email_outbox").fetch_one(&db).await.unwrap(); sqlx::query_as("SELECT array_agg(id ORDER BY id) FROM email_outbox").fetch_one(&db).await.unwrap();
assert_eq!(left, vec![recent, unsent]); assert_eq!(left, vec![recent, unsent]);
@@ -398,6 +401,78 @@ mod analyses {
assert!(requests[0]["messages"][1]["content"].as_str().unwrap().contains("- personality: ")); assert!(requests[0]["messages"][1]["content"].as_str().unwrap().contains("- personality: "));
} }
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn prompt_previews_run_after_analyses(db: PgPool) {
let s = setup(&db).await;
let preview = Uuid::now_v7();
sqlx::query(
"INSERT INTO prompt_previews (id, kind, chart_id, language, model, system, created_by) \
VALUES ($1, 'summary', $2, 'hu', 'test/summary', 'Próba szabályok.', $3)",
)
.bind(preview)
.bind(s.chart)
.bind(s.user)
.execute(&db)
.await
.unwrap();
let analysis = request_analysis(&db, &s).await;
let (fake, url) = fake_openrouter(vec![
reply(&content(Kind::Natal)),
reply(&json!({"title": "Érzékeny mag", "summary": "Rövid összefoglaló szöveg."})),
(500, json!({})),
])
.await;
let a = analyzer(&db, &url);
// the analysis goes first; the preview only when nothing else is due
let job = a.claim().await.unwrap().expect("the analysis");
assert_eq!(job.id, analysis);
a.handle(job).await;
assert!(a.claim().await.unwrap().is_none());
let job = a.claim_preview().await.unwrap().expect("the preview");
a.handle_preview(job).await;
let (status, title, model, credits): (String, Option<String>, Option<String>, i64) = sqlx::query_as(
"SELECT status, content->>'title', model_used, \
(SELECT count(*) FROM credit_ledger WHERE user_id = p.created_by) \
FROM prompt_previews p WHERE id = $1",
)
.bind(preview)
.fetch_one(&db)
.await
.unwrap();
assert_eq!((status.as_str(), title.is_some(), model.as_deref()), ("done", true, Some("test/model-2026")));
let before = credits;
{
let requests = fake.requests.lock().unwrap();
assert_eq!(requests[1]["model"], "test/summary");
assert_eq!(requests[1]["messages"][0]["content"], "Próba szabályok.");
}
// one attempt only: an error fails the preview at once, without refunds
let second = Uuid::now_v7();
sqlx::query(
"INSERT INTO prompt_previews (id, kind, chart_id, language, model, system, created_by) \
VALUES ($1, 'natal', $2, 'hu', 'test/model', 'Másik.', $3)",
)
.bind(second)
.bind(s.chart)
.bind(s.user)
.execute(&db)
.await
.unwrap();
a.handle_preview(a.claim_preview().await.unwrap().unwrap()).await;
let (status, error, credits): (String, Option<String>, i64) = sqlx::query_as(
"SELECT status, error, (SELECT count(*) FROM credit_ledger WHERE user_id = p.created_by) \
FROM prompt_previews p WHERE id = $1",
)
.bind(second)
.fetch_one(&db)
.await
.unwrap();
assert_eq!((status.as_str(), error.is_some(), credits), ("failed", true, before));
assert!(a.claim_preview().await.unwrap().is_none());
}
#[sqlx::test(migrator = "db::MIGRATOR")] #[sqlx::test(migrator = "db::MIGRATOR")]
async fn retries_bad_answers_then_fails_and_refunds(db: PgPool) { async fn retries_bad_answers_then_fails_and_refunds(db: PgPool) {
let s = setup(&db).await; let s = setup(&db).await;