lm15 1.0.0-rc.7

//! The playground's Rust snippets (lm15-ts/examples/provider-page), one
//! function each, so `cargo check --examples` proves the code the page
//! shows compiles against this crate. Generated by
//! `npm run rust:snippets` in lm15-ts; do not edit by hand. Nothing here
//! runs: `main` never calls these (they would need keys and a network).
#![allow(dead_code, unused_variables, unused_mut, clippy::all)]

mod openai_first_turn {
    use futures_util::StreamExt;
    use lm15::{Config, LMRouter, Message, Request, ResponseStream, RouterConfig};

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router = LMRouter::with_config(RouterConfig::new().api_key("openai", "YOUR_API_KEY"))?;

        let request = Request {
            model: "openai:gpt-4.1-mini".into(),
            messages: vec![Message::user(
                "Quotes \" and a newline\n</script> are text, not executable code.",
            )?],
            config: Config {
                max_tokens: Some(400),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod openai_with_history {
    use futures_util::StreamExt;
    use lm15::{
        Canonical, Config, LMRouter, Message, Reasoning, Request, ResponseStream, RouterConfig,
    };

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router = LMRouter::with_config(RouterConfig::new().api_key("openai", "YOUR_API_KEY"))?;

        let request = Request {
            model: "openai:gpt-4.1-mini".into(),
            system: Some("Answer briefly.".into()),
            // Earlier turns, replayed exactly as the model produced them.
            messages: vec![
                Message::from_json(
                    &serde_json::json!({"role":"user","parts":[{"type":"text","text":"Earlier question"}]}),
                )?,
                Message::from_json(
                    &serde_json::json!({"role":"assistant","parts":[{"type":"thinking","text":"Earlier hidden reasoning","continuation":[{"provider":"anthropic","kind":"thinking_signature","data":{"signature":"opaque-replay-signature"}}]},{"type":"text","text":"Earlier answer"}]}),
                )?,
                Message::user("Quotes \" and a newline\n</script> are text, not executable code.")?,
            ],
            config: Config {
                max_tokens: Some(64),
                temperature: Some(0.2),
                reasoning: Some(Reasoning::new("low".parse()?)),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod anthropic_first_turn {
    use futures_util::StreamExt;
    use lm15::{Config, LMRouter, Message, Request, ResponseStream, RouterConfig};

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router =
            LMRouter::with_config(RouterConfig::new().api_key("anthropic", "YOUR_API_KEY"))?;

        let request = Request {
            model: "anthropic:claude-haiku-4-5".into(),
            messages: vec![Message::user(
                "Quotes \" and a newline\n</script> are text, not executable code.",
            )?],
            config: Config {
                max_tokens: Some(400),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod anthropic_with_history {
    use futures_util::StreamExt;
    use lm15::{
        Canonical, Config, LMRouter, Message, Reasoning, Request, ResponseStream, RouterConfig,
    };

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router =
            LMRouter::with_config(RouterConfig::new().api_key("anthropic", "YOUR_API_KEY"))?;

        let request = Request {
            model: "anthropic:claude-haiku-4-5".into(),
            system: Some("Answer briefly.".into()),
            // Earlier turns, replayed exactly as the model produced them.
            messages: vec![
                Message::from_json(
                    &serde_json::json!({"role":"user","parts":[{"type":"text","text":"Earlier question"}]}),
                )?,
                Message::from_json(
                    &serde_json::json!({"role":"assistant","parts":[{"type":"thinking","text":"Earlier hidden reasoning","continuation":[{"provider":"anthropic","kind":"thinking_signature","data":{"signature":"opaque-replay-signature"}}]},{"type":"text","text":"Earlier answer"}]}),
                )?,
                Message::user("Quotes \" and a newline\n</script> are text, not executable code.")?,
            ],
            config: Config {
                max_tokens: Some(64),
                temperature: Some(0.2),
                reasoning: Some(Reasoning::new("low".parse()?)),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod gemini_first_turn {
    use futures_util::StreamExt;
    use lm15::{Config, LMRouter, Message, Request, ResponseStream, RouterConfig};

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router = LMRouter::with_config(RouterConfig::new().api_key("gemini", "YOUR_API_KEY"))?;

        let request = Request {
            model: "gemini:gemini-2.5-flash".into(),
            messages: vec![Message::user(
                "Quotes \" and a newline\n</script> are text, not executable code.",
            )?],
            config: Config {
                max_tokens: Some(400),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod gemini_with_history {
    use futures_util::StreamExt;
    use lm15::{
        Canonical, Config, LMRouter, Message, Reasoning, Request, ResponseStream, RouterConfig,
    };

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router = LMRouter::with_config(RouterConfig::new().api_key("gemini", "YOUR_API_KEY"))?;

        let request = Request {
            model: "gemini:gemini-2.5-flash".into(),
            system: Some("Answer briefly.".into()),
            // Earlier turns, replayed exactly as the model produced them.
            messages: vec![
                Message::from_json(
                    &serde_json::json!({"role":"user","parts":[{"type":"text","text":"Earlier question"}]}),
                )?,
                Message::from_json(
                    &serde_json::json!({"role":"assistant","parts":[{"type":"thinking","text":"Earlier hidden reasoning","continuation":[{"provider":"anthropic","kind":"thinking_signature","data":{"signature":"opaque-replay-signature"}}]},{"type":"text","text":"Earlier answer"}]}),
                )?,
                Message::user("Quotes \" and a newline\n</script> are text, not executable code.")?,
            ],
            config: Config {
                max_tokens: Some(64),
                temperature: Some(0.2),
                reasoning: Some(Reasoning::new("low".parse()?)),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod groq_first_turn {
    use futures_util::StreamExt;
    use lm15::{Config, LMRouter, Message, Request, ResponseStream, RouterConfig};

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router = LMRouter::with_config(RouterConfig::new().api_key("groq", "YOUR_API_KEY"))?;

        let request = Request {
            model: "groq:llama-3.3-70b-versatile".into(),
            messages: vec![Message::user(
                "Quotes \" and a newline\n</script> are text, not executable code.",
            )?],
            config: Config {
                max_tokens: Some(400),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod groq_with_history {
    use futures_util::StreamExt;
    use lm15::{
        Canonical, Config, LMRouter, Message, Reasoning, Request, ResponseStream, RouterConfig,
    };

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router = LMRouter::with_config(RouterConfig::new().api_key("groq", "YOUR_API_KEY"))?;

        let request = Request {
            model: "groq:llama-3.3-70b-versatile".into(),
            system: Some("Answer briefly.".into()),
            // Earlier turns, replayed exactly as the model produced them.
            messages: vec![
                Message::from_json(
                    &serde_json::json!({"role":"user","parts":[{"type":"text","text":"Earlier question"}]}),
                )?,
                Message::from_json(
                    &serde_json::json!({"role":"assistant","parts":[{"type":"thinking","text":"Earlier hidden reasoning","continuation":[{"provider":"anthropic","kind":"thinking_signature","data":{"signature":"opaque-replay-signature"}}]},{"type":"text","text":"Earlier answer"}]}),
                )?,
                Message::user("Quotes \" and a newline\n</script> are text, not executable code.")?,
            ],
            config: Config {
                max_tokens: Some(64),
                temperature: Some(0.2),
                reasoning: Some(Reasoning::new("low".parse()?)),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod openrouter_first_turn {
    use futures_util::StreamExt;
    use lm15::{Config, LMRouter, Message, Request, ResponseStream, RouterConfig};

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router =
            LMRouter::with_config(RouterConfig::new().api_key("openrouter", "YOUR_API_KEY"))?;

        let request = Request {
            model: "openrouter:openai/gpt-4.1-mini".into(),
            messages: vec![Message::user(
                "Quotes \" and a newline\n</script> are text, not executable code.",
            )?],
            config: Config {
                max_tokens: Some(400),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod openrouter_with_history {
    use futures_util::StreamExt;
    use lm15::{
        Canonical, Config, LMRouter, Message, Reasoning, Request, ResponseStream, RouterConfig,
    };

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router =
            LMRouter::with_config(RouterConfig::new().api_key("openrouter", "YOUR_API_KEY"))?;

        let request = Request {
            model: "openrouter:openai/gpt-4.1-mini".into(),
            system: Some("Answer briefly.".into()),
            // Earlier turns, replayed exactly as the model produced them.
            messages: vec![
                Message::from_json(
                    &serde_json::json!({"role":"user","parts":[{"type":"text","text":"Earlier question"}]}),
                )?,
                Message::from_json(
                    &serde_json::json!({"role":"assistant","parts":[{"type":"thinking","text":"Earlier hidden reasoning","continuation":[{"provider":"anthropic","kind":"thinking_signature","data":{"signature":"opaque-replay-signature"}}]},{"type":"text","text":"Earlier answer"}]}),
                )?,
                Message::user("Quotes \" and a newline\n</script> are text, not executable code.")?,
            ],
            config: Config {
                max_tokens: Some(64),
                temperature: Some(0.2),
                reasoning: Some(Reasoning::new("low".parse()?)),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod deepseek_first_turn {
    use futures_util::StreamExt;
    use lm15::{Config, LMRouter, Message, Request, ResponseStream, RouterConfig};

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router =
            LMRouter::with_config(RouterConfig::new().api_key("deepseek", "YOUR_API_KEY"))?;

        let request = Request {
            model: "deepseek:deepseek-chat".into(),
            messages: vec![Message::user(
                "Quotes \" and a newline\n</script> are text, not executable code.",
            )?],
            config: Config {
                max_tokens: Some(400),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod deepseek_with_history {
    use futures_util::StreamExt;
    use lm15::{
        Canonical, Config, LMRouter, Message, Reasoning, Request, ResponseStream, RouterConfig,
    };

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router =
            LMRouter::with_config(RouterConfig::new().api_key("deepseek", "YOUR_API_KEY"))?;

        let request = Request {
            model: "deepseek:deepseek-chat".into(),
            system: Some("Answer briefly.".into()),
            // Earlier turns, replayed exactly as the model produced them.
            messages: vec![
                Message::from_json(
                    &serde_json::json!({"role":"user","parts":[{"type":"text","text":"Earlier question"}]}),
                )?,
                Message::from_json(
                    &serde_json::json!({"role":"assistant","parts":[{"type":"thinking","text":"Earlier hidden reasoning","continuation":[{"provider":"anthropic","kind":"thinking_signature","data":{"signature":"opaque-replay-signature"}}]},{"type":"text","text":"Earlier answer"}]}),
                )?,
                Message::user("Quotes \" and a newline\n</script> are text, not executable code.")?,
            ],
            config: Config {
                max_tokens: Some(64),
                temperature: Some(0.2),
                reasoning: Some(Reasoning::new("low".parse()?)),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod zai_first_turn {
    use futures_util::StreamExt;
    use lm15::{Config, LMRouter, Message, Request, ResponseStream, RouterConfig};

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router = LMRouter::with_config(RouterConfig::new().api_key("zai", "YOUR_API_KEY"))?;

        let request = Request {
            model: "zai:glm-4.5".into(),
            messages: vec![Message::user(
                "Quotes \" and a newline\n</script> are text, not executable code.",
            )?],
            config: Config {
                max_tokens: Some(400),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod zai_with_history {
    use futures_util::StreamExt;
    use lm15::{
        Canonical, Config, LMRouter, Message, Reasoning, Request, ResponseStream, RouterConfig,
    };

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router = LMRouter::with_config(RouterConfig::new().api_key("zai", "YOUR_API_KEY"))?;

        let request = Request {
            model: "zai:glm-4.5".into(),
            system: Some("Answer briefly.".into()),
            // Earlier turns, replayed exactly as the model produced them.
            messages: vec![
                Message::from_json(
                    &serde_json::json!({"role":"user","parts":[{"type":"text","text":"Earlier question"}]}),
                )?,
                Message::from_json(
                    &serde_json::json!({"role":"assistant","parts":[{"type":"thinking","text":"Earlier hidden reasoning","continuation":[{"provider":"anthropic","kind":"thinking_signature","data":{"signature":"opaque-replay-signature"}}]},{"type":"text","text":"Earlier answer"}]}),
                )?,
                Message::user("Quotes \" and a newline\n</script> are text, not executable code.")?,
            ],
            config: Config {
                max_tokens: Some(64),
                temperature: Some(0.2),
                reasoning: Some(Reasoning::new("low".parse()?)),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod meta_first_turn {
    use futures_util::StreamExt;
    use lm15::{Config, LMRouter, Message, Request, ResponseStream, RouterConfig};

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router = LMRouter::with_config(RouterConfig::new().api_key("meta", "YOUR_API_KEY"))?;

        let request = Request {
            model: "meta:muse-spark-1.3".into(),
            messages: vec![Message::user(
                "Quotes \" and a newline\n</script> are text, not executable code.",
            )?],
            config: Config {
                max_tokens: Some(400),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod meta_with_history {
    use futures_util::StreamExt;
    use lm15::{
        Canonical, Config, LMRouter, Message, Reasoning, Request, ResponseStream, RouterConfig,
    };

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router = LMRouter::with_config(RouterConfig::new().api_key("meta", "YOUR_API_KEY"))?;

        let request = Request {
            model: "meta:muse-spark-1.3".into(),
            system: Some("Answer briefly.".into()),
            // Earlier turns, replayed exactly as the model produced them.
            messages: vec![
                Message::from_json(
                    &serde_json::json!({"role":"user","parts":[{"type":"text","text":"Earlier question"}]}),
                )?,
                Message::from_json(
                    &serde_json::json!({"role":"assistant","parts":[{"type":"thinking","text":"Earlier hidden reasoning","continuation":[{"provider":"anthropic","kind":"thinking_signature","data":{"signature":"opaque-replay-signature"}}]},{"type":"text","text":"Earlier answer"}]}),
                )?,
                Message::user("Quotes \" and a newline\n</script> are text, not executable code.")?,
            ],
            config: Config {
                max_tokens: Some(64),
                temperature: Some(0.2),
                reasoning: Some(Reasoning::new("low".parse()?)),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod moonshotai_first_turn {
    use futures_util::StreamExt;
    use lm15::{Config, LMRouter, Message, Request, ResponseStream, RouterConfig};

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router =
            LMRouter::with_config(RouterConfig::new().api_key("moonshotai", "YOUR_API_KEY"))?;

        let request = Request {
            model: "moonshotai:kimi-k2.5".into(),
            messages: vec![Message::user(
                "Quotes \" and a newline\n</script> are text, not executable code.",
            )?],
            config: Config {
                max_tokens: Some(400),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod moonshotai_with_history {
    use futures_util::StreamExt;
    use lm15::{
        Canonical, Config, LMRouter, Message, Reasoning, Request, ResponseStream, RouterConfig,
    };

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router =
            LMRouter::with_config(RouterConfig::new().api_key("moonshotai", "YOUR_API_KEY"))?;

        let request = Request {
            model: "moonshotai:kimi-k2.5".into(),
            system: Some("Answer briefly.".into()),
            // Earlier turns, replayed exactly as the model produced them.
            messages: vec![
                Message::from_json(
                    &serde_json::json!({"role":"user","parts":[{"type":"text","text":"Earlier question"}]}),
                )?,
                Message::from_json(
                    &serde_json::json!({"role":"assistant","parts":[{"type":"thinking","text":"Earlier hidden reasoning","continuation":[{"provider":"anthropic","kind":"thinking_signature","data":{"signature":"opaque-replay-signature"}}]},{"type":"text","text":"Earlier answer"}]}),
                )?,
                Message::user("Quotes \" and a newline\n</script> are text, not executable code.")?,
            ],
            config: Config {
                max_tokens: Some(64),
                temperature: Some(0.2),
                reasoning: Some(Reasoning::new("low".parse()?)),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod ollama_first_turn {
    use futures_util::StreamExt;
    use lm15::{Config, LMRouter, Message, Request, ResponseStream, RouterConfig};

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router = LMRouter::with_config(RouterConfig::new().api_key("ollama", "unused"))?;

        let request = Request {
            model: "ollama:qwen3.5:0.8b".into(),
            messages: vec![Message::user(
                "Quotes \" and a newline\n</script> are text, not executable code.",
            )?],
            config: Config {
                max_tokens: Some(400),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod ollama_with_history {
    use futures_util::StreamExt;
    use lm15::{
        Canonical, Config, LMRouter, Message, Reasoning, Request, ResponseStream, RouterConfig,
    };

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router = LMRouter::with_config(RouterConfig::new().api_key("ollama", "unused"))?;

        let request = Request {
            model: "ollama:qwen3.5:0.8b".into(),
            system: Some("Answer briefly.".into()),
            // Earlier turns, replayed exactly as the model produced them.
            messages: vec![
                Message::from_json(
                    &serde_json::json!({"role":"user","parts":[{"type":"text","text":"Earlier question"}]}),
                )?,
                Message::from_json(
                    &serde_json::json!({"role":"assistant","parts":[{"type":"thinking","text":"Earlier hidden reasoning","continuation":[{"provider":"anthropic","kind":"thinking_signature","data":{"signature":"opaque-replay-signature"}}]},{"type":"text","text":"Earlier answer"}]}),
                )?,
                Message::user("Quotes \" and a newline\n</script> are text, not executable code.")?,
            ],
            config: Config {
                max_tokens: Some(64),
                temperature: Some(0.2),
                reasoning: Some(Reasoning::new("low".parse()?)),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod custom_first_turn {
    use futures_util::StreamExt;
    use lm15::{Config, LMRouter, Message, Request, ResponseStream, RouterConfig};

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router = LMRouter::with_config(
            RouterConfig::new()
                .api_key("openai-chat", "unused")
                .base_url("openai-chat", "http://localhost:1234/v1"),
        )?;

        let request = Request {
            model: "openai-chat:custom-model".into(),
            messages: vec![Message::user(
                "Quotes \" and a newline\n</script> are text, not executable code.",
            )?],
            config: Config {
                max_tokens: Some(400),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

mod custom_with_history {
    use futures_util::StreamExt;
    use lm15::{
        Canonical, Config, LMRouter, Message, Reasoning, Request, ResponseStream, RouterConfig,
    };

    pub async fn run() -> Result<(), Box<dyn std::error::Error>> {
        let router = LMRouter::with_config(
            RouterConfig::new()
                .api_key("openai-chat", "unused")
                .base_url("openai-chat", "http://localhost:1234/v1"),
        )?;

        let request = Request {
            model: "openai-chat:custom-model".into(),
            system: Some("Answer briefly.".into()),
            // Earlier turns, replayed exactly as the model produced them.
            messages: vec![
                Message::from_json(
                    &serde_json::json!({"role":"user","parts":[{"type":"text","text":"Earlier question"}]}),
                )?,
                Message::from_json(
                    &serde_json::json!({"role":"assistant","parts":[{"type":"thinking","text":"Earlier hidden reasoning","continuation":[{"provider":"anthropic","kind":"thinking_signature","data":{"signature":"opaque-replay-signature"}}]},{"type":"text","text":"Earlier answer"}]}),
                )?,
                Message::user("Quotes \" and a newline\n</script> are text, not executable code.")?,
            ],
            config: Config {
                max_tokens: Some(64),
                temperature: Some(0.2),
                reasoning: Some(Reasoning::new("low".parse()?)),
                ..Default::default()
            },
            ..Default::default()
        };

        let mut result = ResponseStream::new(router.stream(&request), &request); // drop it to stop
        while let Some(text) = result.text_chunks().next().await {
            print!("{}", text?);
        }

        // Keep the reply for the next turn.
        let response = result.response().await?;
        let mut messages = request.messages.clone();
        messages.push(response.message.clone());
        Ok(())
    }
}

fn main() {}