AI assistants: settings per site, organisation and repository e71846aa07b9

-- AI assistants (hub spec §13.4, #97): chat-completion endpoints the hub

-- may ask to review a proposal or draft its description. Each lives at

-- one level (site: scope_id 0; an organisation; a repository) and each

-- level may add a prompt. Tokens are sealed with keys/assistants.key.

CREATE TABLE assistants (

    id          INTEGER PRIMARY KEY,

    scope       TEXT NOT NULL CHECK (scope IN ('site', 'org', 'repo')),

    scope_id    INTEGER NOT NULL DEFAULT 0,

    name        TEXT NOT NULL COLLATE NOCASE,

    endpoint    TEXT NOT NULL,

    api         TEXT NOT NULL,

    model       TEXT NOT NULL,

    headers     TEXT NOT NULL DEFAULT '',

    token       BLOB NOT NULL,

    enabled     INTEGER NOT NULL DEFAULT 1,

    budget      INTEGER NOT NULL DEFAULT 120000,

    created_ms  INTEGER NOT NULL,

    updated_ms  INTEGER NOT NULL,

    UNIQUE (scope, scope_id, name)

);

CREATE TABLE assistant_prompts (

    scope       TEXT NOT NULL CHECK (scope IN ('site', 'org', 'repo')),

    scope_id    INTEGER NOT NULL DEFAULT 0,

    prompt      TEXT NOT NULL,

    updated_ms  INTEGER NOT NULL,

    PRIMARY KEY (scope, scope_id)

);

//! AI assistants (hub spec §13.4, #97): chat-completion endpoints the hub

//! may ask to review a proposal or draft its description. Assistants are

//! kept at three levels, site, organisation and repository, and combined

//! downwards: a repository sees its organisation's and the site's beside

//! its own, the innermost of a name wins, and one disabled at an outer

//! level is off for everything inside it. Each level adds a prompt; the

//! prompt in force for a repository is the site's, the organisation's and

//! the repository's own, each under a heading. Tokens are sealed with

//! ChaCha20-Poly1305 under `keys/assistants.key`, shown masked, and never

//! leave the server.

use crate::db::{now_ms, Pool};

use crate::Shared;

use rand::RngCore;

use ring::aead;

use sqlx::FromRow;

use std::path::Path;

use std::time::Duration;

/// The request shapes an assistant may speak.

pub const APIS: [&str; 2] = ["chat-completions", "anthropic-messages"];

/// Characters of context (prompt, description, diffs) a call may carry

/// unless the assistant says otherwise.

pub const DEFAULT_BUDGET: i64 = 120_000;

/// How long one call may take.

pub const CALL_TIMEOUT: Duration = Duration::from_secs(60);

/// The most an answer is kept.

const MAX_ANSWER: usize = 64 * 1024;

/// Which level an assistant or a prompt belongs to.

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub enum Scope {

    Site,

    Org(i64),

    Repo(i64),

}

impl Scope {

    pub fn kind(self) -> &'static str {

        match self {

            Scope::Site => "site",

            Scope::Org(_) => "org",

            Scope::Repo(_) => "repo",

        }

    }

    pub fn id(self) -> i64 {

        match self {

            Scope::Site => 0,

            Scope::Org(id) | Scope::Repo(id) => id,

        }

    }

}

#[derive(Clone, Debug, FromRow)]

pub struct Assistant {

    pub id: i64,

    pub scope: String,

    pub scope_id: i64,

    pub name: String,

    pub endpoint: String,

    /// One of [`APIS`].

    pub api: String,

    pub model: String,

    /// Extra request headers, one `Name: value` per line.

    pub headers: String,

    /// The sealed token; empty when the endpoint needs none.

    pub token: Vec<u8>,

    pub enabled: bool,

    pub budget: i64,

    pub created_ms: i64,

    pub updated_ms: i64,

}

impl Assistant {

    pub fn scope(&self) -> Scope {

        match self.scope.as_str() {

            "org" => Scope::Org(self.scope_id),

            "repo" => Scope::Repo(self.scope_id),

            _ => Scope::Site,

        }

    }

    pub fn has_token(&self) -> bool {

        !self.token.is_empty()

    }

    /// The extra headers as pairs; malformed lines are skipped.

    pub fn header_list(&self) -> Vec<(String, String)> {

        parse_headers(&self.headers).unwrap_or_default()

    }

}

/// What a settings form supplies for an assistant.

#[derive(Clone, Debug, Default)]

pub struct Fields {

    pub name: String,

    pub endpoint: String,

    pub api: String,

    pub model: String,

    pub headers: String,

    pub enabled: bool,

    pub budget: i64,

}

/// `Name: value` lines to pairs: `Err(line)` names the first bad one.

pub fn parse_headers(text: &str) -> Result<Vec<(String, String)>, String> {

    let mut out = vec![];

    for line in text.lines().map(str::trim).filter(|l| !l.is_empty()) {

        let Some((name, value)) = line.split_once(':') else { return Err(line.to_string()) };

        let (name, value) = (name.trim(), value.trim());

        let name_ok = !name.is_empty() && name.chars().all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_');

        if !name_ok || value.chars().any(|c| c.is_control()) {

            return Err(line.to_string());

        }

        out.push((name.to_string(), value.to_string()));

    }

    Ok(out)

}

// -------------------------------------------------------------- sealing

/// The key that seals tokens, kept in `<data>/keys/assistants.key`.

#[derive(Clone)]

pub struct SecretKey([u8; 32]);

impl SecretKey {

    pub fn load_or_create(keys: &Path) -> anyhow::Result<SecretKey> {

        std::fs::create_dir_all(keys)?;

        let path = keys.join("assistants.key");

        if let Ok(bytes) = std::fs::read(&path) {

            if bytes.len() == 32 {

                return Ok(SecretKey(bytes.try_into().unwrap()));

            }

        }

        let mut k = [0u8; 32];

        rand::rngs::OsRng.fill_bytes(&mut k);

        std::fs::write(&path, k)?;

        #[cfg(unix)]

        {

            use std::os::unix::fs::PermissionsExt;

            std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600))?;

        }

        Ok(SecretKey(k))

    }

    fn key(&self) -> aead::LessSafeKey {

        aead::LessSafeKey::new(aead::UnboundKey::new(&aead::CHACHA20_POLY1305, &self.0).expect("key length"))

    }

    /// Seal a token: a random nonce, then the ciphertext and tag. An

    /// empty token seals to nothing, meaning "no token".

    pub fn seal(&self, plain: &str) -> Vec<u8> {

        if plain.is_empty() {

            return vec![];

        }

        let mut nonce = [0u8; 12];

        rand::rngs::OsRng.fill_bytes(&mut nonce);

        let mut out = plain.as_bytes().to_vec();

        self.key().seal_in_place_append_tag(aead::Nonce::assume_unique_for_key(nonce), aead::Aad::empty(), &mut out).expect("seal");

        let mut sealed = nonce.to_vec();

        sealed.extend(out);

        sealed

    }

    /// The token back, or `None` when the bytes were sealed under another

    /// key or damaged. Nothing opens to an empty token.

    pub fn open(&self, sealed: &[u8]) -> Option<String> {

        if sealed.is_empty() {

            return Some(String::new());

        }

        let (nonce, rest) = sealed.split_at_checked(12)?;

        let mut buf = rest.to_vec();

        let nonce = aead::Nonce::try_assume_unique_for_key(nonce).ok()?;

        let plain = self.key().open_in_place(nonce, aead::Aad::empty(), &mut buf).ok()?;

        String::from_utf8(plain.to_vec()).ok()

    }

}

// ------------------------------------------------------------- storage

pub async fn list(pool: &Pool, scope: Scope) -> sqlx::Result<Vec<Assistant>> {

    sqlx::query_as("SELECT * FROM assistants WHERE scope = ? AND scope_id = ? ORDER BY name")

        .bind(scope.kind())

        .bind(scope.id())

        .fetch_all(pool)

        .await

}

pub async fn get(pool: &Pool, id: i64) -> sqlx::Result<Option<Assistant>> {

    sqlx::query_as("SELECT * FROM assistants WHERE id = ?").bind(id).fetch_optional(pool).await

}

/// Add an assistant; `None` when the level already has one of that name.

pub async fn create(pool: &Pool, scope: Scope, f: &Fields, token: &[u8]) -> sqlx::Result<Option<Assistant>> {

    let now = now_ms();

    let r = sqlx::query_as(

        "INSERT INTO assistants (scope, scope_id, name, endpoint, api, model, headers, token, enabled, budget, created_ms, updated_ms) \

         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT DO NOTHING RETURNING *",

    )

    .bind(scope.kind())

    .bind(scope.id())

    .bind(&f.name)

    .bind(&f.endpoint)

    .bind(&f.api)

    .bind(&f.model)

    .bind(&f.headers)

    .bind(token)

    .bind(f.enabled)

    .bind(f.budget)

    .bind(now)

    .bind(now)

    .fetch_optional(pool)

    .await?;

    Ok(r)

}

/// Change an assistant's details; `token` is `None` to keep the stored

/// one. False when the name is taken at that level.

pub async fn update(pool: &Pool, id: i64, f: &Fields, token: Option<&[u8]>) -> sqlx::Result<bool> {

    let r = match token {

        Some(t) => sqlx::query(

            "UPDATE assistants SET name = ?, endpoint = ?, api = ?, model = ?, headers = ?, enabled = ?, budget = ?, token = ?, updated_ms = ? \

             WHERE id = ? AND NOT EXISTS (SELECT 1 FROM assistants o WHERE o.scope = assistants.scope AND o.scope_id = assistants.scope_id AND o.name = ? AND o.id <> ?)",

        )

        .bind(&f.name)

        .bind(&f.endpoint)

        .bind(&f.api)

        .bind(&f.model)

        .bind(&f.headers)

        .bind(f.enabled)

        .bind(f.budget)

        .bind(t)

        .bind(now_ms())

        .bind(id)

        .bind(&f.name)

        .bind(id)

        .execute(pool)

        .await?,

        None => sqlx::query(

            "UPDATE assistants SET name = ?, endpoint = ?, api = ?, model = ?, headers = ?, enabled = ?, budget = ?, updated_ms = ? \

             WHERE id = ? AND NOT EXISTS (SELECT 1 FROM assistants o WHERE o.scope = assistants.scope AND o.scope_id = assistants.scope_id AND o.name = ? AND o.id <> ?)",

        )

        .bind(&f.name)

        .bind(&f.endpoint)

        .bind(&f.api)

        .bind(&f.model)

        .bind(&f.headers)

        .bind(f.enabled)

        .bind(f.budget)

        .bind(now_ms())

        .bind(id)

        .bind(&f.name)

        .bind(id)

        .execute(pool)

        .await?,

    };

    Ok(r.rows_affected() == 1)

}

pub async fn set_enabled(pool: &Pool, id: i64, enabled: bool) -> sqlx::Result<()> {

    sqlx::query("UPDATE assistants SET enabled = ?, updated_ms = ? WHERE id = ?")

        .bind(enabled)

        .bind(now_ms())

        .bind(id)

        .execute(pool)

        .await?;

    Ok(())

}

pub async fn delete(pool: &Pool, id: i64) -> sqlx::Result<()> {

    sqlx::query("DELETE FROM assistants WHERE id = ?").bind(id).execute(pool).await?;

    Ok(())

}

/// Forget a level's assistants and prompt, when the organisation or

/// repository goes.

pub async fn delete_scope(pool: &Pool, scope: Scope) -> sqlx::Result<()> {

    sqlx::query("DELETE FROM assistants WHERE scope = ? AND scope_id = ?").bind(scope.kind()).bind(scope.id()).execute(pool).await?;

    sqlx::query("DELETE FROM assistant_prompts WHERE scope = ? AND scope_id = ?").bind(scope.kind()).bind(scope.id()).execute(pool).await?;

    Ok(())

}

/// The prompt a level adds, empty when none.

pub async fn prompt(pool: &Pool, scope: Scope) -> sqlx::Result<String> {

    Ok(sqlx::query_scalar("SELECT prompt FROM assistant_prompts WHERE scope = ? AND scope_id = ?")

        .bind(scope.kind())

        .bind(scope.id())

        .fetch_optional(pool)

        .await?

        .unwrap_or_default())

}

pub async fn set_prompt(pool: &Pool, scope: Scope, text: &str) -> sqlx::Result<()> {

    if text.trim().is_empty() {

        sqlx::query("DELETE FROM assistant_prompts WHERE scope = ? AND scope_id = ?")

            .bind(scope.kind())

            .bind(scope.id())

            .execute(pool)

            .await?;

    } else {

        sqlx::query(

            "INSERT INTO assistant_prompts (scope, scope_id, prompt, updated_ms) VALUES (?, ?, ?, ?) \

             ON CONFLICT (scope, scope_id) DO UPDATE SET prompt = excluded.prompt, updated_ms = excluded.updated_ms",

        )

        .bind(scope.kind())

        .bind(scope.id())

        .bind(text.trim())

        .bind(now_ms())

        .execute(pool)

        .await?;

    }

    Ok(())

}

// ----------------------------------------------------- what applies where

/// The levels above a scope, outermost first: the site, then the

/// organisation when the owner is one.

pub async fn levels_above(pool: &Pool, scope: Scope, owner: &str) -> sqlx::Result<Vec<(Scope, String)>> {

    let mut out = vec![];

    match scope {

        Scope::Site => {}

        Scope::Org(_) => out.push((Scope::Site, "the site".to_string())),

        Scope::Repo(_) => {

            out.push((Scope::Site, "the site".to_string()));

            if let Some(org) = crate::db::accounts::org_by_name(pool, owner).await? {

                out.push((Scope::Org(org.id), format!("the {} organisation", org.name)));

            }

        }

    }

    Ok(out)

}

/// An assistant seen from a level: where it comes from, and whether it is

/// on once outer levels have had their say.

#[derive(Clone, Debug)]

pub struct Available {

    pub assistant: Assistant,

    /// `the site`, `the acme organisation`, or empty for the level's own.

    pub from: String,

    /// Off because a level above disabled an assistant of this name.

    pub off_above: bool,

}

impl Available {

    pub fn on(&self) -> bool {

        self.assistant.enabled && !self.off_above

    }

}

/// Every assistant a level sees, outermost first, one per name: the

/// innermost definition of a name wins, and a name disabled at an outer

/// level is off inside it whatever the inner level says.

pub async fn available(pool: &Pool, scope: Scope, owner: &str) -> sqlx::Result<Vec<Available>> {

    let mut levels = levels_above(pool, scope, owner).await?;

    levels.push((scope, String::new()));

    let mut out: Vec<Available> = vec![];

    let mut off: Vec<String> = vec![];

    for (level, from) in levels {

        for a in list(pool, level).await? {

            let off_above = off.iter().any(|n| n.eq_ignore_ascii_case(&a.name));

            if !a.enabled && !off.iter().any(|n| n.eq_ignore_ascii_case(&a.name)) {

                off.push(a.name.clone());

            }

            out.retain(|o| !o.assistant.name.eq_ignore_ascii_case(&a.name));

            out.push(Available { assistant: a, from: from.clone(), off_above });

        }

    }

    Ok(out)

}

/// The assistants a repository may ask, by name.

pub async fn enabled_for_repo(pool: &Pool, repo: &crate::db::repos::RepoRow) -> sqlx::Result<Vec<Assistant>> {

    Ok(available(pool, Scope::Repo(repo.id), &repo.owner).await?.into_iter().filter(Available::on).map(|a| a.assistant).collect())

}

/// The prompts a level inherits, outermost first: (where from, text),

/// only the levels that set one.

pub async fn inherited_prompts(pool: &Pool, scope: Scope, owner: &str) -> sqlx::Result<Vec<(String, String)>> {

    let mut out = vec![];

    for (level, from) in levels_above(pool, scope, owner).await? {

        let text = prompt(pool, level).await?;

        if !text.is_empty() {

            out.push((from, text));

        }

    }

    Ok(out)

}

/// The prompt in force for a repository: each level's text under a

/// heading, outermost first, so a project adds to what the site says.

pub async fn prompt_for_repo(pool: &Pool, repo: &crate::db::repos::RepoRow) -> sqlx::Result<String> {

    let scope = Scope::Repo(repo.id);

    let mut parts = inherited_prompts(pool, scope, &repo.owner).await?;

    let own = prompt(pool, scope).await?;

    if !own.is_empty() {

        parts.push(("this repository".to_string(), own));

    }

    Ok(parts.into_iter().map(|(from, text)| format!("## Instructions from {from}\n\n{text}\n")).collect::<Vec<_>>().join("\n"))

}

// -------------------------------------------------------------- calling

/// Ask an assistant: the system prompt and the request, the answer's

/// text. Errors are for the person who asked: a status and the first

/// line of what the endpoint said, or why no answer came.

pub async fn ask(app: &Shared, a: &Assistant, system: &str, user: &str) -> Result<String, String> {

    let Some(token) = app.assistant_key.open(&a.token) else {

        return Err("its token cannot be read: set it again".into());

    };

    let client = reqwest::Client::builder()

        .timeout(CALL_TIMEOUT)

        .user_agent(format!("oxygenhub/{}", env!("CARGO_PKG_VERSION")))

        .build()

        .map_err(|e| e.to_string())?;

    let mut req = client.post(&a.endpoint).header("content-type", "application/json");

    let body = match a.api.as_str() {

        "anthropic-messages" => {

            if !token.is_empty() {

                req = req.header("x-api-key", &token);

            }

            req = req.header("anthropic-version", "2023-06-01");

            serde_json::json!({

                "model": a.model,

                "max_tokens": 4096,

                "system": system,

                "messages": [{ "role": "user", "content": user }],

            })

        }

        _ => {

            if !token.is_empty() {

                req = req.header("authorization", format!("Bearer {token}"));

            }

            serde_json::json!({

                "model": a.model,

                "messages": [

                    { "role": "system", "content": system },

                    { "role": "user", "content": user },

                ],

            })

        }

    };

    for (name, value) in a.header_list() {

        req = req.header(name, value);

    }

    let r = req.json(&body).send().await.map_err(|e| {

        if e.is_timeout() {

            "no answer within 60 seconds".to_string()

        } else {

            scrub(&e.to_string(), &token)

        }

    })?;

    let status = r.status();

    let text: String = r.text().await.unwrap_or_default().chars().take(MAX_ANSWER).collect();

    if !status.is_success() {

        let why = serde_json::from_str::<serde_json::Value>(&text)

            .ok()

            .and_then(|v| v["error"]["message"].as_str().or(v["error"].as_str()).or(v["message"].as_str()).map(str::to_string))

            .unwrap_or_else(|| text.lines().next().unwrap_or("").chars().take(160).collect());

        return Err(scrub(&format!("{} {}", status.as_u16(), why.trim()), &token));

    }

    let v: serde_json::Value = serde_json::from_str(&text).map_err(|_| "the answer was not JSON".to_string())?;

    let answer = match a.api.as_str() {

        "anthropic-messages" => v["content"]

            .as_array()

            .map(|parts| parts.iter().filter_map(|p| p["text"].as_str()).collect::<Vec<_>>().join(""))

            .unwrap_or_default(),

        _ => match &v["choices"][0]["message"]["content"] {

            serde_json::Value::String(s) => s.clone(),

            serde_json::Value::Array(parts) => parts.iter().filter_map(|p| p["text"].as_str()).collect::<Vec<_>>().join(""),

            _ => String::new(),

        },

    };

    if answer.trim().is_empty() {

        return Err("the answer carried no text".into());

    }

    Ok(answer)

}

/// A tiny exchange, for the settings page's TEST: the start of the answer.

pub async fn test(app: &Shared, a: &Assistant) -> Result<String, String> {

    let answer = ask(app, a, "You are being connected to an OxygenHub site. Answer briefly.", "Reply with the single word OK.").await?;

    Ok(answer.trim().chars().take(80).collect())

}

/// Never let the token through in an error message.

fn scrub(text: &str, token: &str) -> String {

    if token.is_empty() {

        text.to_string()

    } else {

        text.replace(token, "***")

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn tokens_seal_and_open_only_under_their_key() {

        let dir = tempfile::tempdir().unwrap();

        let k = SecretKey::load_or_create(dir.path()).unwrap();

        let sealed = k.seal("sk-very-secret");

        assert_ne!(sealed, b"sk-very-secret");

        assert!(!String::from_utf8_lossy(&sealed).contains("secret"));

        assert_eq!(k.open(&sealed).as_deref(), Some("sk-very-secret"));

        assert_eq!(SecretKey::load_or_create(dir.path()).unwrap().open(&sealed).as_deref(), Some("sk-very-secret"), "the key is kept");

        let other = SecretKey::load_or_create(tempfile::tempdir().unwrap().path()).unwrap();

        assert_eq!(other.open(&sealed), None);

        assert_eq!(k.open(&[1, 2, 3]), None);

        assert_eq!(k.seal(""), Vec::<u8>::new());

        assert_eq!(k.open(&[]).as_deref(), Some(""));

    }

    #[test]

    fn headers_parse_or_name_the_bad_line() {

        assert_eq!(

            parse_headers("X-Org: acme\n\n OpenAI-Beta : v1 ").unwrap(),

            vec![("X-Org".into(), "acme".into()), ("OpenAI-Beta".into(), "v1".into())]

        );

        assert_eq!(parse_headers("no colon").unwrap_err(), "no colon");

        assert_eq!(parse_headers("bad name: x").unwrap_err(), "bad name: x");

    }

}

//! The AI assistants panel (hub spec §13.4, #97) shared by the

//! administration, organisation and repository settings pages: the

//! level's own assistants, the ones it inherits, and its prompt.

use crate::assistants::{self, Assistant, Available, Fields, Scope, APIS, DEFAULT_BUDGET};

use crate::auth::Viewer;

use crate::db::accounts;

use crate::Shared;

use serde::Deserialize;

/// Whose panel.

pub struct Where {

    pub scope: Scope,

    /// The owner name, so a repository finds its organisation.

    pub owner: String,

    /// What the audit log names.

    pub label: String,

}

#[derive(Deserialize)]

pub struct AssistantForm {

    #[serde(rename = "_csrf")]

    pub csrf_token: String,

    #[serde(default)]

    action: String,

    #[serde(default)]

    id: Option<i64>,

    #[serde(default)]

    name: String,

    #[serde(default)]

    endpoint: String,

    #[serde(default)]

    api: String,

    #[serde(default)]

    model: String,

    #[serde(default)]

    headers: String,

    #[serde(default)]

    token: String,

    #[serde(default)]

    enabled: Option<String>,

    #[serde(default)]

    budget: String,

    #[serde(default)]

    prompt: String,

}

/// Everything the panel shows.

pub struct Panel {

    /// The level's own assistants, each with whether a level above turned

    /// its name off.

    pub own: Vec<Available>,

    /// The ones the levels above provide, outermost first.

    pub inherited: Vec<Available>,

    pub prompt: String,

    /// (where from, text) for each level above that set a prompt.

    pub inherited_prompts: Vec<(String, String)>,

    pub apis: Vec<&'static str>,

    pub default_budget: i64,

}

pub async fn panel(app: &Shared, at: &Where) -> sqlx::Result<Panel> {

    let (own, inherited): (Vec<_>, Vec<_>) =

        assistants::available(&app.db, at.scope, &at.owner).await?.into_iter().partition(|a| a.from.is_empty());

    Ok(Panel {

        own,

        inherited,

        prompt: assistants::prompt(&app.db, at.scope).await?,

        inherited_prompts: assistants::inherited_prompts(&app.db, at.scope, &at.owner).await?,

        apis: APIS.to_vec(),

        default_budget: DEFAULT_BUDGET,

    })

}

fn name_ok(name: &str) -> bool {

    !name.is_empty() && name.chars().count() <= 40 && name.chars().all(|c| c.is_alphanumeric() || matches!(c, ' ' | '.' | '-' | '_'))

}

fn endpoint_ok(url: &str) -> bool {

    (url.starts_with("http://") || url.starts_with("https://")) && url.len() <= 2000 && !url.contains(char::is_whitespace)

}

/// The form's details checked: `Err` is the message for the person.

fn fields(f: &AssistantForm) -> Result<Fields, String> {

    let name = f.name.trim().to_string();

    if !name_ok(&name) {

        return Err("An assistant's name is up to 40 letters, digits, spaces, dots, dashes or underscores.".into());

    }

    let endpoint = f.endpoint.trim().to_string();

    if !endpoint_ok(&endpoint) {

        return Err("The endpoint is the full URL the request is posted to, starting with https://.".into());

    }

    if !APIS.contains(&f.api.as_str()) {

        return Err("The API is chat-completions or anthropic-messages.".into());

    }

    let model = f.model.trim().to_string();

    if model.is_empty() || model.len() > 100 || model.contains(char::is_whitespace) {

        return Err("A model name is needed, such as claude-opus-5-5 or gpt-5.".into());

    }

    let headers = f.headers.trim().to_string();

    if let Err(line) = assistants::parse_headers(&headers) {

        return Err(format!("Extra headers are one Name: value per line; this line is not: {line}"));

    }

    if headers.lines().count() > 10 {

        return Err("Up to ten extra headers.".into());

    }

    let budget = if f.budget.trim().is_empty() {

        DEFAULT_BUDGET

    } else {

        match f.budget.trim().parse::<i64>() {

            Ok(n) if (1_000..=2_000_000).contains(&n) => n,

            _ => return Err("The context budget is a number of characters from 1000 to 2000000.".into()),

        }

    };

    Ok(Fields { name, endpoint, api: f.api.clone(), model, headers, enabled: f.enabled.is_some(), budget })

}

/// Apply the panel's form: `Ok(notice)` or `Err(message for the user)`.

pub async fn apply(app: &Shared, viewer: &Viewer, at: &Where, f: AssistantForm) -> sqlx::Result<Result<String, String>> {

    let owned = |a: Option<Assistant>| a.filter(|a| a.scope() == at.scope);

    let actor = viewer.account();

    Ok(Ok(match (f.action.as_str(), f.id) {

        ("add", None) => {

            let fields = match fields(&f) {

                Ok(x) => x,

                Err(e) => return Ok(Err(e)),

            };

            let token = app.assistant_key.seal(f.token.trim());

            match assistants::create(&app.db, at.scope, &fields, &token).await? {

                Some(a) => {

                    accounts::audit(&app.db, actor, "assistant.added", &at.label, &a.name).await.ok();

                    format!("{} added.", a.name)

                }

                None => return Ok(Err(format!("There is already an assistant called {} here.", fields.name))),

            }

        }

        ("update", Some(id)) => {

            let Some(a) = owned(assistants::get(&app.db, id).await?) else { return Ok(Err("No such assistant.".into())) };

            let fields = match fields(&f) {

                Ok(x) => x,

                Err(e) => return Ok(Err(e)),

            };

            let token = f.token.trim();

            let sealed = (!token.is_empty()).then(|| app.assistant_key.seal(token));

            if !assistants::update(&app.db, id, &fields, sealed.as_deref()).await? {

                return Ok(Err(format!("There is already an assistant called {} here.", fields.name)));

            }

            accounts::audit(&app.db, actor, "assistant.updated", &at.label, &a.name).await.ok();

            format!("{} updated.", fields.name)

        }

        ("toggle", Some(id)) => {

            let Some(a) = owned(assistants::get(&app.db, id).await?) else { return Ok(Err("No such assistant.".into())) };

            assistants::set_enabled(&app.db, id, !a.enabled).await?;

            accounts::audit(&app.db, actor, if a.enabled { "assistant.disabled" } else { "assistant.enabled" }, &at.label, &a.name)

                .await

                .ok();

            format!("{} is {}.", a.name, if a.enabled { "off" } else { "on" })

        }

        ("delete", Some(id)) => {

            let Some(a) = owned(assistants::get(&app.db, id).await?) else { return Ok(Err("No such assistant.".into())) };

            assistants::delete(&app.db, id).await?;

            accounts::audit(&app.db, actor, "assistant.deleted", &at.label, &a.name).await.ok();

            format!("{} deleted.", a.name)

        }

        ("test", Some(id)) => {

            let Some(a) = owned(assistants::get(&app.db, id).await?) else { return Ok(Err("No such assistant.".into())) };

            match assistants::test(app, &a).await {

                Ok(answer) => format!("{} answered: {answer}", a.name),

                Err(why) => return Ok(Err(format!("{} did not answer: {why}", a.name))),

            }

        }

        ("prompt", _) => {

            if f.prompt.chars().count() > 20_000 {

                return Ok(Err("A prompt is up to 20000 characters.".into()));

            }

            assistants::set_prompt(&app.db, at.scope, &f.prompt).await?;

            accounts::audit(&app.db, actor, "assistant.prompt", &at.label, "").await.ok();

            if f.prompt.trim().is_empty() {

                "Prompt cleared.".to_string()

            } else {

                "Prompt saved.".to_string()

            }

        }

        _ => return Ok(Err("Unknown action.".into())),

    }))

}

{% macro panel(base, a, csrf, what) %}

<section class="panel" id="assistants">

  <h2>AI assistants</h2>

  <p class="small mute">{{ what }} An assistant reviews a proposal when asked, or drafts its description; its answers are shown as the person who asked, via the assistant. It never approves.</p>

  {% if !a.inherited.is_empty() %}

  <h3>Inherited</h3>

  <ul class="hooks">

  {% for i in a.inherited %}

  <li class="hook">

    <div class="hook-head"><strong>{{ i.assistant.name }}</strong> <span class="tag">{{ i.assistant.model }}</span>

      {% if i.on() %}<span class="tag head">on</span>{% else if i.off_above %}<span class="tag dim">off above</span>{% else %}<span class="tag dim">off</span>{% endif %}

      <span class="small mute">from {{ i.from }}</span></div>

  </li>

  {% endfor %}

  </ul>

  {% endif %}

  {% if a.own.is_empty() %}<p class="mute small">{% if a.inherited.is_empty() %}None.{% else %}None of its own.{% endif %}</p>{% else %}

  <ul class="hooks">

  {% for o in a.own %}{% let r = o.assistant %}

  <li class="hook">

    <div class="hook-head">

      <strong>{{ r.name }}</strong> <span class="tag">{{ r.model }}</span> <span class="tag">{{ r.api }}</span>

      {% if o.on() %}<span class="tag head">on</span>{% else if o.off_above %}<span class="tag dim" title="An assistant of this name is turned off at a level above">off above</span>{% else %}<span class="tag dim">off</span>{% endif %}

    </div>

    <p class="small mute"><code>{{ r.endpoint }}</code> · token {% if r.has_token() %}set{% else %}none{% endif %} · context {{ r.budget }} characters</p>

    <form class="tiny" method="post" action="{{ base }}/assistants"><input type="hidden" name="_csrf" value="{{ csrf }}"><input type="hidden" name="id" value="{{ r.id }}"><button name="action" value="toggle">{% if r.enabled %}turn off{% else %}turn on{% endif %}</button> <button name="action" value="test">test</button> <button name="action" value="delete" class="danger-btn" onclick="return confirm('Delete {{ r.name }}?')">delete</button></form>

    <details class="hook-edit"><summary class="small">edit</summary>

      <form class="card" method="post" action="{{ base }}/assistants">

        <input type="hidden" name="_csrf" value="{{ csrf }}"><input type="hidden" name="id" value="{{ r.id }}"><input type="hidden" name="action" value="update">

        <label for="an{{ r.id }}">Name</label><input type="text" id="an{{ r.id }}" name="name" value="{{ r.name }}">

        <label for="ae{{ r.id }}">Endpoint</label><input type="text" id="ae{{ r.id }}" name="endpoint" value="{{ r.endpoint }}" autocomplete="off">

        <label for="aa{{ r.id }}">API</label>

        <select id="aa{{ r.id }}" name="api">{% for api in a.apis %}<option value="{{ api }}"{% if r.api == *api %} selected{% endif %}>{{ api }}</option>{% endfor %}</select>

        <label for="am{{ r.id }}">Model</label><input type="text" id="am{{ r.id }}" name="model" value="{{ r.model }}">

        <label for="at{{ r.id }}">Token</label><input type="password" id="at{{ r.id }}" name="token" placeholder="{% if r.has_token() %}unchanged{% else %}none{% endif %}" autocomplete="new-password">

        <label for="ah{{ r.id }}">Extra headers</label><textarea id="ah{{ r.id }}" name="headers" rows="2" placeholder="Name: value">{{ r.headers }}</textarea>

        <label for="ab{{ r.id }}">Context budget (characters)</label><input type="text" id="ab{{ r.id }}" name="budget" value="{{ r.budget }}">

        <div class="choice"><label><input type="checkbox" name="enabled" value="1"{% if r.enabled %} checked{% endif %}> on</label></div>

        <button type="submit">SAVE</button>

      </form>

    </details>

  </li>

  {% endfor %}

  </ul>{% endif %}

  <form class="card" method="post" action="{{ base }}/assistants">

    <input type="hidden" name="_csrf" value="{{ csrf }}"><input type="hidden" name="action" value="add">

    <h3>Add an assistant</h3>

    <label for="aname">Name</label><input type="text" id="aname" name="name" placeholder="Claude" required>

    <label for="aendpoint">Endpoint</label><input type="text" id="aendpoint" name="endpoint" placeholder="https://api.anthropic.com/v1/messages" required autocomplete="off">

    <label for="aapi">API</label>

    <select id="aapi" name="api">{% for api in a.apis %}<option value="{{ api }}">{{ api }}{% if *api == "chat-completions" %} (OpenAI, DeepSeek, Ollama, most others){% else %} (Anthropic){% endif %}</option>{% endfor %}</select>

    <label for="amodel">Model</label><input type="text" id="amodel" name="model" placeholder="claude-opus-5-5" required>

    <label for="atoken">Token</label><input type="password" id="atoken" name="token" autocomplete="new-password">

    <p class="small mute">Sent as a bearer token, or as the API key for Anthropic; kept sealed on the server and never shown again. Leave it empty for an endpoint that needs none.</p>

    <label for="aheaders">Extra headers</label><textarea id="aheaders" name="headers" rows="2" placeholder="Name: value"></textarea>

    <label for="abudget">Context budget (characters)</label><input type="text" id="abudget" name="budget" value="{{ a.default_budget }}">

    <div class="choice"><label><input type="checkbox" name="enabled" value="1" checked> on</label></div>

    <button type="submit">ADD</button>

  </form>

  <form class="card" method="post" action="{{ base }}/assistants">

    <input type="hidden" name="_csrf" value="{{ csrf }}"><input type="hidden" name="action" value="prompt">

    <h3>Prompt</h3>

    {% for (from, text) in a.inherited_prompts %}<details><summary class="small mute">From {{ from }}</summary><pre class="snippet">{{ text }}</pre></details>{% endfor %}

    <label for="aprompt">What every assistant is told here{% if !a.inherited_prompts.is_empty() %}, after the prompts above{% endif %}</label>

    <textarea id="aprompt" name="prompt" rows="6" placeholder="Review for correctness first. This project is written in Rust; the style guide is in docs/style.md.">{{ a.prompt }}</textarea>

    <button type="submit">SAVE PROMPT</button>

  </form>

</section>

{% endmacro %}

- **AI assistants, step one: settings (#97).** Administration, an organisation's settings and a repository's settings each hold a list of assistants (name, endpoint, API shape, model, extra headers, token, context budget, on or off) and a prompt. A repository sees its organisation's and the site's beside its own; the innermost of a name wins and one turned off above is off below. Tokens are sealed with ChaCha20-Poly1305 under `keys/assistants.key` and never shown again; TEST sends a one-line exchange. Review requests and drafted descriptions follow.

 "ring",

# Seals assistant tokens at rest (hub spec §13.4); already in the tree through rustls.

ring = "0.17"

pub mod assistants;

    /// Seals AI assistants' tokens at rest (hub spec §13.4).

    pub assistant_key: assistants::SecretKey,

    let assistant_key = assistants::SecretKey::load_or_create(&config.keys_dir())?;

        assistant_key,

    /// The site's AI assistants and prompt (#97).

    assistants: super::assistants::Panel,

    let assistants = super::assistants::panel(app, &site_assistants()).await.map_err(e)?;

        assistants,

fn site_assistants() -> super::assistants::Where {

    super::assistants::Where { scope: crate::assistants::Scope::Site, owner: String::new(), label: "site".into() }

}

/// `POST /admin/assistants`: the site's assistants and prompt (#97).

pub async fn assistants(

    State(app): State<Shared>,

    viewer: Viewer,

    Form(f): Form<super::assistants::AssistantForm>,

) -> Result<Page<AdminPage>, Error> {

    let shell = Shell::new(&app, "/admin", &viewer);

    require_admin(&viewer, &shell)?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    let outcome = super::assistants::apply(&app, &viewer, &site_assistants(), f).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    admin_page(&app, shell, Some(outcome.unwrap_or_else(|e| e))).await

}

mod assistants;

        .route("/orgs/{name}/settings/assistants", post(orgs::assistants))

        .route("/admin/assistants", post(admin::assistants))

        .route("/{owner}/{name}/settings/assistants", post(repo_settings::assistants))

    /// The organisation's AI assistants and prompt (#97).

    assistants: super::assistants::Panel,

    let assistants = super::assistants::panel(app, &org_assistants(&org)).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    Ok(Page(OrgSettingsPage { shell, org, members, teams, hooks, notice, error, runners, runner_token: None, assistants }))

fn org_assistants(org: &accounts::Organisation) -> super::assistants::Where {

    super::assistants::Where { scope: crate::assistants::Scope::Org(org.id), owner: org.name.clone(), label: org.name.clone() }

}

/// `POST /orgs/{name}/settings/assistants`: the organisation's assistants

/// and prompt (#97).

pub async fn assistants(

    State(app): State<Shared>,

    viewer: Viewer,

    Path(name): Path<String>,

    Form(f): Form<super::assistants::AssistantForm>,

) -> Result<Page<OrgSettingsPage>, Error> {

    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);

    let (_, org) = owned_org(&app, &shell, &viewer, &name).await?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    match super::assistants::apply(&app, &viewer, &org_assistants(&org), f).await.map_err(|e| Error::from_db(shell.clone(), e))? {

        Ok(notice) => org_page(&app, shell, org, Some(notice), None).await,

        Err(error) => org_page(&app, shell, org, None, Some(error)).await,

    }

}

    /// The repository's AI assistants and prompt (#97).

    assistants: super::assistants::Panel,

    let assistants = super::assistants::panel(app, &repo_assistants(&row)).await.map_err(|e| Error::from_db(shell.clone(), e))?;

        assistants,

    crate::assistants::delete_scope(&app.db, crate::assistants::Scope::Repo(row.id)).await.ok();

fn repo_assistants(row: &db::repos::RepoRow) -> super::assistants::Where {

    super::assistants::Where {

        scope: crate::assistants::Scope::Repo(row.id),

        owner: row.owner.clone(),

        label: format!("{}/{}", row.owner, row.name),

    }

}

/// `POST /{owner}/{name}/settings/assistants`: the repository's assistants

/// and prompt (#97), for its admins.

pub async fn assistants(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<super::assistants::AssistantForm>,

) -> Result<Page<RepoSettingsPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    match super::assistants::apply(&app, &viewer, &repo_assistants(&row), f).await.map_err(|e| Error::from_db(shell.clone(), e))? {

        Ok(notice) => settings_page(&app, shell, row, role, Some(notice), None).await,

        Err(error) => settings_page(&app, shell, row, role, None, Some(error)).await,

    }

}

/// A stand-in chat-completions endpoint: answers "OK from mock" and keeps

/// the Authorization header and body of each call.

async fn mock_assistant() -> (String, std::sync::Arc<std::sync::Mutex<Vec<String>>>) {

    use std::sync::{Arc, Mutex};

    let seen: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));

    let s2 = seen.clone();

    let router = axum::Router::new().route(

        "/v1/chat/completions",

        axum::routing::post(move |headers: axum::http::HeaderMap, body: String| {

            let s2 = s2.clone();

            async move {

                let auth = headers.get("authorization").and_then(|v| v.to_str().ok()).unwrap_or("").to_string();

                s2.lock().unwrap().push(format!("{auth} {body}"));

                axum::Json(serde_json::json!({ "choices": [{ "message": { "role": "assistant", "content": "OK from mock" } }] }))

            }

        }),

    );

    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();

    let port = listener.local_addr().unwrap().port();

    tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });

    (format!("http://127.0.0.1:{port}/v1/chat/completions"), seen)

}

fn enc(s: &str) -> String {

    s.replace('%', "%25").replace(':', "%3A").replace('/', "%2F").replace(' ', "+").replace('\n', "%0A").replace('&', "%26")

}

#[tokio::test(flavor = "multi_thread")]

async fn ai_assistants_are_kept_per_level_with_sealed_tokens_and_combined_downwards() {

    use oxygenhub::assistants::{self, Scope};

    let h = hub().await;

    let app = &h.app;

    let andy = register(app, "andy", "").await;

    let (endpoint, seen) = mock_assistant().await;

    // The site level: an administrator adds Claude with a token.

    let page = get(app, "/admin", Some(&andy)).await.body;

    assert!(page.contains("AI assistants") && page.contains("Add an assistant"), "{page}");

    let csrf = csrf_of(&page);

    let add = |name: &str, extra: &str| {

        format!(

            "_csrf={csrf}&action=add&name={name}&endpoint={}&api=chat-completions&model=claude-opus-5-5&token=sk-test-secret&enabled=1&budget=50000{extra}",

            enc(&endpoint)

        )

    };

    let r = post(app, "/admin/assistants", Some(&andy), &add("Claude", "")).await;

    assert!(r.body.contains("Claude added.") && r.body.contains("token set"), "{}", r.body);

    assert!(!r.body.contains("sk-test-secret"), "the token never comes back");

    let site = assistants::list(&app.db, Scope::Site).await.unwrap();

    assert_eq!(site.len(), 1);

    let claude = &site[0];

    assert!(!String::from_utf8_lossy(&claude.token).contains("sk-test"), "sealed at rest");

    assert_eq!(app.assistant_key.open(&claude.token).as_deref(), Some("sk-test-secret"));

    // A second of the same name is refused; a bad endpoint is explained.

    let r = post(app, "/admin/assistants", Some(&andy), &add("claude", "")).await;

    assert!(r.body.contains("already an assistant called"), "{}", r.body);

    let r = post(

        app,

        "/admin/assistants",

        Some(&andy),

        &format!("_csrf={csrf}&action=add&name=Bad&endpoint=ftp%3A%2F%2Fx&api=chat-completions&model=m"),

    )

    .await;

    assert!(r.body.contains("starting with https://"), "{}", r.body);

    // TEST calls the endpoint with the bearer token and shows the answer.

    let r = post(app, "/admin/assistants", Some(&andy), &format!("_csrf={csrf}&action=test&id={}", claude.id)).await;

    assert!(r.body.contains("Claude answered: OK from mock"), "{}", r.body);

    {

        let calls = seen.lock().unwrap();

        assert_eq!(calls.len(), 1);

        assert!(calls[0].starts_with("Bearer sk-test-secret "), "{}", calls[0]);

        assert!(calls[0].contains("\"model\":\"claude-opus-5-5\"") && calls[0].contains("Reply with the single word OK"), "{}", calls[0]);

    }

    // An update with the token field empty keeps the stored token.

    let r = post(

        app,

        "/admin/assistants",

        Some(&andy),

        &format!("_csrf={csrf}&action=update&id={}&name=Claude&endpoint={}&api=chat-completions&model=claude-opus-5-5&token=&enabled=1&budget=60000", claude.id, enc(&endpoint)),

    )

    .await;

    assert!(r.body.contains("Claude updated.") && r.body.contains("context 60000 characters"), "{}", r.body);

    assert_eq!(

        app.assistant_key.open(&assistants::get(&app.db, claude.id).await.unwrap().unwrap().token).as_deref(),

        Some("sk-test-secret")

    );

    // The site prompt.

    let r =

        post(app, "/admin/assistants", Some(&andy), &format!("_csrf={csrf}&action=prompt&prompt={}", enc("Review for correctness first.")))

            .await;

    assert!(r.body.contains("Prompt saved.") && r.body.contains("Review for correctness first."), "{}", r.body);

    // An organisation and its repository see the site's assistant and prompt.

    let r = post(app, "/orgs/new", Some(&andy), &format!("_csrf={csrf}&name=acme&display_name=Acme")).await;

    assert_eq!(r.status, StatusCode::SEE_OTHER, "{}", r.body);

    let r = post(app, "/new", Some(&andy), &format!("_csrf={csrf}&owner=acme&name=plans&visibility=public")).await;

    assert_eq!(r.status, StatusCode::SEE_OTHER, "{}", r.body);

    let org_page = get(app, "/orgs/acme/settings", Some(&andy)).await.body;

    assert!(org_page.contains("Inherited") && org_page.contains("from the site") && org_page.contains("None of its own"), "{org_page}");

    assert!(org_page.contains("From the site") && org_page.contains("Review for correctness first."), "{org_page}");

    let repo = db::repos::get(&app.db, "acme", "plans").await.unwrap().unwrap();

    let on = assistants::enabled_for_repo(&app.db, &repo).await.unwrap();

    assert_eq!(on.iter().map(|a| a.name.as_str()).collect::<Vec<_>>(), ["Claude"]);

    // The organisation adds a prompt and its own DeepSeek; the repository

    // sees both levels' prompts under headings, outermost first.

    let r = post(

        app,

        "/orgs/acme/settings/assistants",

        Some(&andy),

        &format!("_csrf={csrf}&action=prompt&prompt={}", enc("We write 6502 assembly.")),

    )

    .await;

    assert!(r.body.contains("Prompt saved."), "{}", r.body);

    let r = post(app, "/orgs/acme/settings/assistants", Some(&andy), &add("DeepSeek", "")).await;

    assert!(r.body.contains("DeepSeek added."), "{}", r.body);

    let prompt = assistants::prompt_for_repo(&app.db, &repo).await.unwrap();

    assert!(prompt.starts_with("## Instructions from the site\n\nReview for correctness first.\n\n## Instructions from the acme organisation\n\nWe write 6502 assembly."), "{prompt}");

    let repo_page = get(app, "/acme/plans/settings", Some(&andy)).await.body;

    assert!(repo_page.contains("from the acme organisation") && repo_page.contains("From the acme organisation"), "{repo_page}");

    let on = assistants::enabled_for_repo(&app.db, &repo).await.unwrap();

    assert_eq!(on.iter().map(|a| a.name.as_str()).collect::<Vec<_>>(), ["Claude", "DeepSeek"]);

    // Turning Claude off at the site turns it off below, even where a

    // repository defines its own Claude; turning it back on lets the

    // repository's own definition win.

    let r = post(app, "/admin/assistants", Some(&andy), &format!("_csrf={csrf}&action=toggle&id={}", claude.id)).await;

    assert!(r.body.contains("Claude is off."), "{}", r.body);

    let r = post(app, "/acme/plans/settings/assistants", Some(&andy), &add("Claude", "")).await;

    assert!(r.body.contains("Claude added."), "{}", r.body);

    let on = assistants::enabled_for_repo(&app.db, &repo).await.unwrap();

    assert_eq!(on.iter().map(|a| a.name.as_str()).collect::<Vec<_>>(), ["DeepSeek"]);

    let repo_page = get(app, "/acme/plans/settings", Some(&andy)).await.body;

    assert!(repo_page.contains("off above"), "{repo_page}");

    post(app, "/admin/assistants", Some(&andy), &format!("_csrf={csrf}&action=toggle&id={}", claude.id)).await;

    let on = assistants::enabled_for_repo(&app.db, &repo).await.unwrap();

    assert_eq!(on.iter().map(|a| (a.name.as_str(), a.scope.as_str())).collect::<Vec<_>>(), [("DeepSeek", "org"), ("Claude", "repo")]);

    // Only administrators and owners reach the panels.

    let invite = {

        let r = post(app, "/admin/invite", Some(&andy), &format!("_csrf={csrf}")).await;

        let i = r.body.find("invite=").map(|i| i + 7).expect("an invitation");

        r.body[i..].chars().take_while(|c| c.is_ascii_alphanumeric()).collect::<String>()

    };

    let bob = register(app, "bob", &invite).await;

    assert_eq!(

        post(app, "/admin/assistants", Some(&bob), &format!("_csrf={csrf}&action=prompt&prompt=x")).await.status,

        StatusCode::NOT_FOUND

    );

    assert_eq!(

        post(app, "/orgs/acme/settings/assistants", Some(&bob), &format!("_csrf={csrf}&action=prompt&prompt=x")).await.status,

        StatusCode::NOT_FOUND

    );

    assert_eq!(

        post(app, "/acme/plans/settings/assistants", Some(&bob), &format!("_csrf={csrf}&action=prompt&prompt=x")).await.status,

        StatusCode::NOT_FOUND

    );

    // Deleting the repository forgets its assistants and prompt.

    let r = post(app, "/acme/plans/settings/delete", Some(&andy), &format!("_csrf={csrf}&confirm=acme%2Fplans")).await;

    assert!(r.status == StatusCode::SEE_OTHER || r.status == StatusCode::OK, "{} {}", r.status, r.body);

    assert!(assistants::list(&app.db, Scope::Repo(repo.id)).await.unwrap().is_empty());

}

### 13.4 AI assistants (settings done 2026-10-04; review requests and drafts planned)

- **Secrets.** Tokens are sealed at rest with ChaCha20-Poly1305 under `keys/assistants.key` (mode 0600, made at first start beside the cookie key; each token carries its own random nonce), shown only as set or none, and never returned by the API. An empty token suits endpoints that need none. Each settings panel has TEST, a one-line exchange whose answer or error is shown. Each level's changes are in the audit log (`assistant.added`, `.updated`, `.enabled`, `.disabled`, `.deleted`, `.prompt`).

{% import "assistants_panel.html" as ai %}

{% call ai::panel("/admin", assistants, shell.csrf, "Every repository on the site may ask these, unless an organisation or repository turns one off.") %}

{% import "assistants_panel.html" as ai %}

  <a href="#assistants">AI assistants</a>

{% call ai::panel("/orgs/" ~ org.name ~ "/settings", assistants, shell.csrf, "Every repository of the organisation may ask these, beside the site's and its own.") %}

{% import "assistants_panel.html" as ai %}

  <a href="#assistants">AI assistants</a>

{% call ai::panel(repo.url ~ "/settings", assistants, shell.csrf, "This repository may ask these, beside the ones the site and its owner provide.") %}