chore: promote staging to staging-promote/428303af-23255149035 (2026-03-18 19:20 UTC)

.env.example

@@ -78,7 +78,7 @@ NEARAI_AUTH_URL=https://private.near.ai
 # === MiniMax ===
 # LLM_BACKEND=minimax
 # MINIMAX_API_KEY=...
-# MINIMAX_MODEL=MiniMax-M2.5
+# MINIMAX_MODEL=MiniMax-M2.7
 # MINIMAX_BASE_URL=https://api.minimax.io/v1   # default (global); use https://api.minimaxi.com/v1 for China
 
 # === Anthropic Direct ===

README.md

@@ -17,7 +17,8 @@
 <p align="center">
   <a href="README.md">English</a> |
   <a href="README.zh-CN.md">简体中文</a> |
-  <a href="README.ru.md">Русский</a>
+  <a href="README.ru.md">Русский</a> |
+  <a href="README.ja.md">日本語</a>
 </p>
 
 <p align="center">

README.ru.md

@@ -17,7 +17,8 @@
 <p align="center">
   <a href="README.md">English</a> |
   <a href="README.zh-CN.md">简体中文</a> |
-  <a href="README.ru.md">Русский</a>
+  <a href="README.ru.md">Русский</a> |
+  <a href="README.ja.md">日本語</a>
 </p>
 
 <p align="center">

README.zh-CN.md

@@ -17,7 +17,8 @@
 <p align="center">
   <a href="README.md">English</a> |
   <a href="README.zh-CN.md">简体中文</a> |
-  <a href="README.ru.md">Русский</a>
+  <a href="README.ru.md">Русский</a> |
+  <a href="README.ja.md">日本語</a>
 </p>
 
 <p align="center">

codecov.yml

@@ -2,9 +2,13 @@ coverage:
   status:
     project:
       default:
-        target: auto
-        threshold: 1%
+        target: 80%
+        threshold: 2%
     patch:
       default:
-        target: 80%
-        threshold: 5%
+        target: 90%
+
+comment:
+  layout: "reach,diff,flags"
+  behavior: default
+  require_changes: true

docs/LLM_PROVIDERS.md

@@ -15,7 +15,7 @@ configurations.
 | io.net | `ionet` | `IONET_API_KEY` | Intelligence API |
 | Mistral | `mistral` | `MISTRAL_API_KEY` | Mistral models |
 | Yandex AI Studio | `yandex` | `YANDEX_API_KEY` | YandexGPT models |
-| MiniMax | `minimax` | `MINIMAX_API_KEY` | MiniMax-M2.5 models |
+| MiniMax | `minimax` | `MINIMAX_API_KEY` | MiniMax-M2.7 models |
 | Cloudflare Workers AI | `cloudflare` | `CLOUDFLARE_API_KEY` | Access to Workers AI |
 | Ollama | `ollama` | No | Local inference |
 | AWS Bedrock | `bedrock` | AWS credentials | Native Converse API |
@@ -84,7 +84,7 @@ LLM_BACKEND=minimax
 MINIMAX_API_KEY=...
 ```
 
-Available models: `MiniMax-M2.5` (default), `MiniMax-M2.5-highspeed`
+Available models: `MiniMax-M2.7` (default), `MiniMax-M2.7-highspeed`, `MiniMax-M2.5`, `MiniMax-M2.5-highspeed`
 
 To use the China mainland endpoint, set:
 

providers.json

@@ -393,8 +393,8 @@
     "api_key_required": true,
     "base_url_env": "MINIMAX_BASE_URL",
     "model_env": "MINIMAX_MODEL",
-    "default_model": "MiniMax-M2.5",
-    "description": "MiniMax API (MiniMax-M2.5 and MiniMax-M2.5-highspeed models)",
+    "default_model": "MiniMax-M2.7",
+    "description": "MiniMax API (MiniMax-M2.7, MiniMax-M2.7-highspeed, MiniMax-M2.5 and MiniMax-M2.5-highspeed models)",
     "setup": {
       "kind": "api_key",
       "secret_name": "llm_minimax_api_key",

src/channels/wasm/wrapper.rs

@@ -492,8 +492,16 @@ impl near::agent::channel_host::Host for ChannelStoreData {
                 tracing::debug!(body = %truncated, "Response body");
             }
 
-            // Leak detection on response body (best-effort)
-            if let Ok(body_str) = std::str::from_utf8(&body) {
+            // Leak detection on response body (best-effort).
+            //
+            // Telegram `getUpdates` is special: it is inbound polling data, so
+            // user-pasted secrets can legitimately appear in the response body.
+            // Those messages are still checked later by the inbound message
+            // safety layer before they reach the LLM, so we allow the polling
+            // response to continue here to avoid poisoning the offset state.
+            if let Ok(body_str) = std::str::from_utf8(&body)
+                && !should_skip_response_leak_scan(&url)
+            {
                 leak_detector
                     .scan_and_clean(body_str)
                     .map_err(|e| format!("Potential secret leak in response: {}", e))?;
@@ -3122,6 +3130,19 @@ fn extract_host_from_url(url: &str) -> Option<String> {
     })
 }
 
+fn should_skip_response_leak_scan(url: &str) -> bool {
+    url::Url::parse(url).is_ok_and(|parsed| {
+        matches!(parsed.scheme(), "http" | "https")
+            && parsed
+                .host_str()
+                .is_some_and(|host| host.eq_ignore_ascii_case("api.telegram.org"))
+            && parsed
+                .path_segments()
+                .and_then(|segments| segments.rev().find(|segment| !segment.is_empty()))
+                .is_some_and(|segment| segment == "getUpdates")
+    })
+}
+
 /// Pre-resolve host credentials for all HTTP capability mappings.
 ///
 /// Called once per callback (in async context, before spawn_blocking) so the
@@ -4386,6 +4407,22 @@ mod tests {
         assert_eq!(store.redact_credentials(input), input);
     }
 
+    #[test]
+    fn test_should_skip_response_leak_scan_only_for_telegram_getupdates() {
+        use super::should_skip_response_leak_scan;
+
+        assert!(should_skip_response_leak_scan(
+            "https://api.telegram.org/bot123/getUpdates?offset=1"
+        ));
+        assert!(!should_skip_response_leak_scan(
+            "https://api.telegram.org/bot123/sendMessage"
+        ));
+        assert!(!should_skip_response_leak_scan(
+            "https://api.example.com/getUpdates"
+        ));
+        assert!(!should_skip_response_leak_scan("not a url"));
+    }
+
     /// Verify that WASM HTTP host functions work using a dedicated
     /// current-thread runtime inside spawn_blocking.
     #[tokio::test]

src/context/state.rs

@@ -258,6 +258,13 @@ impl JobContext {
         new_state: JobState,
         reason: Option<String>,
     ) -> Result<(), String> {
+        debug_assert!(
+            self.state.can_transition_to(new_state),
+            "BUG: invalid job state transition {} -> {} for job {}",
+            self.state,
+            new_state,
+            self.job_id
+        );
         if !self.state.can_transition_to(new_state) {
             return Err(format!(
                 "Cannot transition from {} to {}",

src/llm/anthropic_oauth.rs

@@ -22,6 +22,7 @@ use crate::llm::provider::{
     ToolCompletionRequest, ToolCompletionResponse, strip_unsupported_completion_params,
     strip_unsupported_tool_params,
 };
+use crate::llm::retry::cap_retry_after;
 
 const ANTHROPIC_API_URL: &str = "https://api.anthropic.com/v1/messages";
 /// OAuth beta requires 2023-06-01; the 2024-10-22 version is not valid with the beta flag.
@@ -150,6 +151,7 @@ impl AnthropicOAuthProvider {
                 .and_then(|v| v.to_str().ok())
                 .and_then(|v| v.parse::<u64>().ok())
                 .map(std::time::Duration::from_secs)
+                .map(cap_retry_after)
                 .or(Some(std::time::Duration::from_secs(60)));
 
             let response_text = response
@@ -766,9 +768,14 @@ mod tests {
 
     #[test]
     fn test_retry_after_large_number() {
-        // Verify large numbers are accepted
+        // Verify large numbers are capped to the safe maximum
         let duration = parse_retry_after_anthropic_for_test("7200"); // 2 hours
-        assert_eq!(duration, Some(std::time::Duration::from_secs(7200)));
+        assert_eq!(
+            duration,
+            Some(std::time::Duration::from_secs(
+                crate::llm::retry::MAX_RETRY_AFTER_SECS
+            ))
+        );
     }
 
     /// Helper function to test Retry-After header parsing logic for Anthropic
@@ -779,6 +786,7 @@ mod tests {
             .parse::<u64>()
             .ok()
             .map(std::time::Duration::from_secs)
+            .map(cap_retry_after)
             .or(Some(std::time::Duration::from_secs(60)))
     }
 }

src/llm/circuit_breaker.rs

@@ -167,6 +167,12 @@ impl CircuitBreakerProvider {
                 }
             }
             CircuitState::Open => {
+                debug_assert!(
+                    false,
+                    "BUG: record_success() called while circuit breaker is Open — \
+                     check_allowed() was bypassed for provider {}",
+                    self.inner.model_name()
+                );
                 // Shouldn't get here (check_allowed blocks Open), but recover
                 state.state = CircuitState::Closed;
                 state.consecutive_failures = 0;

src/llm/nearai_chat.rs

@@ -22,7 +22,7 @@ use crate::llm::provider::{
     ChatMessage, CompletionRequest, CompletionResponse, FinishReason, LlmProvider, Role, ToolCall,
     ToolCompletionRequest, ToolCompletionResponse,
 };
-use crate::llm::{costs, session::SessionManager};
+use crate::llm::{costs, retry::cap_retry_after, session::SessionManager};
 
 /// Information about an available model from NEAR AI API.
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -252,17 +252,17 @@ impl NearAiChatProvider {
             .and_then(|v| {
                 // Try delay-seconds first (most common from API providers)
                 if let Ok(secs) = v.trim().parse::<u64>() {
-                    return Some(std::time::Duration::from_secs(secs));
+                    return Some(cap_retry_after(std::time::Duration::from_secs(secs)));
                 }
                 // Try HTTP-date (e.g. "Mon, 02 Mar 2026 18:00:00 GMT")
                 if let Ok(dt) = chrono::DateTime::parse_from_rfc2822(v.trim()) {
                     let now = chrono::Utc::now();
                     let delta = dt.signed_duration_since(now);
                     // Use max(0) so past/present dates yield Duration::ZERO
                     // rather than None (which would cause an immediate retry).
-                    return Some(std::time::Duration::from_secs(
-                        delta.num_seconds().max(0) as u64
-                    ));
+                    return Some(cap_retry_after(std::time::Duration::from_secs(
+                        delta.num_seconds().max(0) as u64,
+                    )));
                 }
                 None
             })
@@ -2306,23 +2306,31 @@ mod tests {
 
     #[test]
     fn test_retry_after_large_number() {
-        // Verify large numbers are accepted
+        // Verify large numbers are capped to the safe maximum
         let duration = parse_retry_after_for_test("3600"); // 1 hour
         assert_eq!(duration, Some(std::time::Duration::from_secs(3600)));
+
+        let huge = parse_retry_after_for_test("18446744073709551615");
+        assert_eq!(
+            huge,
+            Some(std::time::Duration::from_secs(
+                crate::llm::retry::MAX_RETRY_AFTER_SECS
+            ))
+        );
     }
 
     /// Helper function to test Retry-After header parsing logic
     /// (simulates the parsing done in send_request without actual HTTP, including fallback)
     fn parse_retry_after_for_test(header_value: &str) -> Option<std::time::Duration> {
         let trimmed = header_value.trim();
         let parsed = if let Ok(secs) = trimmed.parse::<u64>() {
-            Some(std::time::Duration::from_secs(secs))
+            Some(cap_retry_after(std::time::Duration::from_secs(secs)))
         } else if let Ok(dt) = chrono::DateTime::parse_from_rfc2822(trimmed) {
             let now = chrono::Utc::now();
             let delta = dt.signed_duration_since(now);
-            Some(std::time::Duration::from_secs(
-                delta.num_seconds().max(0) as u64
-            ))
+            Some(cap_retry_after(std::time::Duration::from_secs(
+                delta.num_seconds().max(0) as u64,
+            )))
         } else {
             None
         };

src/llm/reasoning_models.rs

@@ -108,6 +108,8 @@ mod tests {
         assert!(has_native_thinking("nanbeige-4.1-3b"));
         assert!(has_native_thinking("step-3.5-flash-197b"));
         assert!(has_native_thinking("minimax-m2.5-139b"));
+        assert!(has_native_thinking("MiniMax-M2.7"));
+        assert!(has_native_thinking("MiniMax-M2.7-highspeed"));
     }
 
     #[test]

src/llm/retry.rs

@@ -19,6 +19,12 @@ use crate::llm::provider::{
     ToolCompletionResponse,
 };
 
+/// Upper bound for provider-suggested `Retry-After` delays.
+///
+/// This prevents malicious or malformed headers from turning a retryable
+/// response into an effectively unbounded sleep.
+pub(crate) const MAX_RETRY_AFTER_SECS: u64 = 3600;
+
 /// Returns `true` if the `LlmError` is transient and the request should be retried.
 ///
 /// Used by `RetryProvider` (retry the same provider) and `FailoverProvider`
@@ -67,6 +73,11 @@ pub(crate) fn retry_backoff_delay(attempt: u32) -> Duration {
     Duration::from_millis(delay_ms)
 }
 
+/// Clamp a provider-suggested retry delay to a safe maximum.
+pub(crate) fn cap_retry_after(duration: Duration) -> Duration {
+    duration.min(Duration::from_secs(MAX_RETRY_AFTER_SECS))
+}
+
 /// Configuration for the retry decorator.
 #[derive(Debug, Clone)]
 pub struct RetryConfig {
@@ -421,4 +432,16 @@ mod tests {
             panic!("Expected RateLimited error");
         }
     }
+
+    #[test]
+    fn cap_retry_after_clamps_huge_delays() {
+        assert_eq!(
+            cap_retry_after(Duration::from_secs(u64::MAX)),
+            Duration::from_secs(MAX_RETRY_AFTER_SECS)
+        );
+        assert_eq!(
+            cap_retry_after(Duration::from_secs(0)),
+            Duration::from_secs(0)
+        );
+    }
 }

src/setup/channels.rs

@@ -518,7 +518,7 @@ pub async fn setup_http(secrets: &SecretsContext) -> Result<HttpSetupResult, Cha
             .save_secret("http_webhook_secret", &SecretString::from(secret))
             .await?;
         print_success("Webhook secret generated and saved to database");
-        print_info("Retrieve it later with: ironclaw secret get http_webhook_secret");
+        print_info(http_webhook_secret_hint());
     }
 
     print_success(&format!("HTTP webhook will listen on {}:{}", host, port));
@@ -535,6 +535,10 @@ pub fn generate_webhook_secret() -> String {
     generate_secret_with_length(32)
 }
 
+fn http_webhook_secret_hint() -> &'static str {
+    "The secret is stored in the encrypted secrets database and will be loaded automatically on startup."
+}
+
 fn validate_e164(account: &str) -> Result<(), String> {
     if !account.starts_with('+') {
         return Err("E.164 account must start with '+'".to_string());
@@ -1136,8 +1140,9 @@ mod tests {
 
     use crate::secrets::{InMemorySecretsStore, SecretsCrypto, SecretsStore};
     use crate::setup::channels::{
-        SecretsContext, generate_webhook_secret, substitute_validation_placeholders,
-        validate_cloudflare_token_format, validate_public_https_url,
+        SecretsContext, generate_webhook_secret, http_webhook_secret_hint,
+        substitute_validation_placeholders, validate_cloudflare_token_format,
+        validate_public_https_url,
     };
 
     fn test_secrets_context() -> SecretsContext {
@@ -1337,4 +1342,12 @@ mod tests {
             .to_string();
         assert!(err.contains("DNS resolution failed"));
     }
+
+    #[test]
+    fn test_http_webhook_secret_hint_reflects_current_behavior() {
+        let hint = http_webhook_secret_hint();
+        assert!(hint.contains("encrypted secrets database"));
+        assert!(hint.contains("loaded automatically on startup"));
+        assert!(!hint.contains("ironclaw secret get"));
+    }
 }