Diffusion reads multi-line lists; assistants say why there is no answer 5360cea36c30

/// How long a call may take while a person waits for it (a draft, a

/// connection test): inside Cloudflare's 100 seconds for a proxied request.

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

/// How long a call answered in the background may take (a review, a

/// summary): a model that thinks first needs minutes on a large proposal

/// (oxygenhub#201).

pub const BACKGROUND_TIMEOUT: Duration = Duration::from_secs(300);

/// The longest answer asked for: room for a model that thinks before it

/// writes (oxygenhub#201: 4096 was spent on thinking alone).

pub const MAX_ANSWER_TOKENS: u32 = 16_000;

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

        .timeout(wait)

                "max_tokens": MAX_ANSWER_TOKENS,

            // No length here: providers differ (`max_tokens`, or

            // `max_completion_tokens` for newer OpenAI models, with

            // different ceilings), and their defaults are generous.

            format!("no answer within {} seconds", wait.as_secs())

    let (answer, stop) = answer_of(&a.api, &v);

    finish(answer, stop)

}

/// Why an answer ended, as the person who asked needs to know it.

#[derive(Debug, PartialEq, Eq)]

enum Stop {

    /// It finished.

    Done,

    /// It reached the length it was allowed (thinking counts against it).

    Length,

    /// The provider declined to answer, with its category if it gave one.

    Declined(Option<String>),

}

/// The text of a provider's answer (text parts only: thinking is not

/// part of the answer), and why it ended.

fn answer_of(api: &str, v: &serde_json::Value) -> (String, Stop) {

    match api {

        "anthropic-messages" => {

            let text = v["content"]

                .as_array()

                .map(|parts| {

                    parts

                        .iter()

                        .filter(|p| p["type"].as_str().is_none_or(|t| t == "text"))

                        .filter_map(|p| p["text"].as_str())

                        .collect::<Vec<_>>()

                        .join("")

                })

                .unwrap_or_default();

            let stop = match v["stop_reason"].as_str() {

                Some("max_tokens") => Stop::Length,

                Some("refusal") => Stop::Declined(v["stop_details"]["category"].as_str().map(str::to_string)),

                _ => Stop::Done,

            };

            (text, stop)

        }

        _ => {

            let choice = &v["choices"][0];

            let text = match &choice["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(),

            };

            let stop = match choice["finish_reason"].as_str() {

                Some("length") => Stop::Length,

                Some("content_filter") => Stop::Declined(None),

                _ => Stop::Done,

            };

            (text, stop)

        }

/// The answer, or why there is none. An answer cut short is kept, with a

/// note saying so.

fn finish(answer: String, stop: Stop) -> Result<String, String> {

    match stop {

        Stop::Declined(category) => Err(match category {

            Some(c) => format!("it declined to answer ({c})"),

            None => "it declined to answer".into(),

        }),

        Stop::Length if answer.trim().is_empty() => {

            Err("it ran out of room before writing an answer (it spent its length limit thinking): try a smaller proposal".into())

        }

        Stop::Length => Ok(format!("{}\n\n*(Cut short: the answer reached its length limit.)*", answer.trim_end())),

        Stop::Done if answer.trim().is_empty() => Err("the answer carried no text".into()),

        Stop::Done => Ok(answer),

    }

}

    let answer =

        ask(app, a, "You are being connected to an OxygenHub site. Answer briefly.", "Reply with the single word OK.", CALL_TIMEOUT)

            .await?;

    }

    #[test]

    fn answers_say_why_they_stopped() {

        let a = |v: serde_json::Value| {

            let (text, stop) = answer_of("anthropic-messages", &v);

            finish(text, stop)

        };

        // #201: all of the length spent thinking.

        let thought = serde_json::json!({ "stop_reason": "max_tokens", "content": [{ "type": "thinking", "thinking": "" }] });

        assert!(a(thought).unwrap_err().contains("ran out of room"));

        let cut = serde_json::json!({ "stop_reason": "max_tokens", "content": [{ "type": "thinking", "thinking": "" }, { "type": "text", "text": "Half" }] });

        assert!(a(cut).unwrap().starts_with("Half\n\n*(Cut short"));

        let declined = serde_json::json!({ "stop_reason": "refusal", "stop_details": { "category": "cyber" }, "content": [] });

        assert_eq!(a(declined).unwrap_err(), "it declined to answer (cyber)");

        let ok = serde_json::json!({ "stop_reason": "end_turn", "content": [{ "type": "text", "text": "Fine." }] });

        assert_eq!(a(ok).unwrap(), "Fine.");

        let chat = |v: serde_json::Value| {

            let (text, stop) = answer_of("chat-completions", &v);

            finish(text, stop)

        };

        assert!(chat(serde_json::json!({ "choices": [{ "finish_reason": "length", "message": { "content": "" } }] }))

            .unwrap_err()

            .contains("ran out of room"));

        assert_eq!(

            chat(serde_json::json!({ "choices": [{ "finish_reason": "content_filter", "message": { "content": "" } }] })).unwrap_err(),

            "it declined to answer"

        );

        assert_eq!(

            chat(serde_json::json!({ "choices": [{ "finish_reason": "stop", "message": { "content": "Yes." } }] })).unwrap(),

            "Yes."

        );

    ask(app, a, &system, &user, BACKGROUND_TIMEOUT).await

    ask(app, a, &system, &user, BACKGROUND_TIMEOUT).await

            ask(app, a, &system, &user, CALL_TIMEOUT).await

    let mut lines = text.lines();

    while let Some(line) = lines.next() {

        // A list may run over several lines (oxygenhub#200), as TOML allows:

        // read on to its closing `]`.

        let mut v = v.trim().to_string();

        if v.starts_with('[') && !v.contains(']') {

            for more in lines.by_ref() {

                let more = more.trim();

                if more.starts_with('#') {

                    continue;

                }

                v.push_str(more);

                if more.contains(']') {

                    break;

                }

            }

        }

        let v = v.as_str();

        // #200: a list over several lines, as in trailblazers, comments

        // and the keys after it included.

        let multi = "[rstar-api]\nurl = https://hub/x\n\nwatch = [\"src/x16/rbm*\",\n         \"src/x16/rdm.c\",\n  # a note\n         \"src/mega65/rsm.c\"]\nfollow = \"green\"\n";

        let (f, _, _, watch) = module_keys(multi, "rstar-api");

        assert_eq!(watch, vec!["src/x16/rbm*", "src/x16/rdm.c", "src/mega65/rsm.c"]);

        assert_eq!(f, Some(Follow::Green), "the key after the list is still read");