feat: 增加最大令牌数至4000，优化内存维护服务的错误处理逻辑

src/gateway/memory_maintenance.rs

@@ -151,12 +151,11 @@ impl MemoryMaintenanceService {
                 ),
             ],
             temperature: Some(0.0),
-            max_tokens: Some(1200),
+            max_tokens: Some(4000),
             tools: None,
         };
 
         let mut last_error = None;
-        let mut response = None;
 
         for (attempt, delay_ms) in MEMORY_MAINTENANCE_RETRY_DELAYS_MS
             .iter()
@@ -165,11 +164,8 @@ impl MemoryMaintenanceService {
             .chain(std::iter::once(None))
             .enumerate()
         {
-            match provider.chat(request.clone()).await {
-                Ok(success) => {
-                    response = Some(success);
-                    break;
-                }
+            let response = match provider.chat(request.clone()).await {
+                Ok(success) => success,
                 Err(err) => {
                     let error_text = err.to_string();
                     let should_retry =
@@ -194,21 +190,35 @@ impl MemoryMaintenanceService {
                         error_text
                     )));
                 }
-            }
-        }
-
-        let response = response.ok_or_else(|| {
-            AgentError::Other(format!(
-                "memory organization model error: {}",
-                last_error.unwrap_or_else(|| "unknown provider error".to_string())
-            ))
-        })?;
+            };
 
             let raw_content = strip_json_code_fence(&response.content);
             let json_candidate = extract_json_object(raw_content).unwrap_or(raw_content);
 
-        let output: MemoryOrganizationOutput =
-            serde_json::from_str(json_candidate).map_err(|err| {
+            match serde_json::from_str::<MemoryOrganizationOutput>(json_candidate) {
+                Ok(parsed) => return Ok(parsed),
+                Err(err) => {
+                    let error_msg = err.to_string();
+                    let is_truncated = error_msg.contains("EOF while parsing")
+                        || error_msg.contains("expected");
+
+                    let should_retry = delay_ms.is_some() && is_truncated;
+                    last_error = Some(error_msg.clone());
+
+                    if should_retry {
+                        tracing::warn!(
+                            scope_key = %scope_key,
+                            attempt = attempt + 1,
+                            retry_in_ms = delay_ms.unwrap_or_default(),
+                            error = %error_msg,
+                            raw_len = raw_content.len(),
+                            "Memory organization JSON parse failed (possibly truncated), retrying"
+                        );
+                        tokio::time::sleep(Duration::from_millis(delay_ms.unwrap_or_default()))
+                            .await;
+                        continue;
+                    }
+
                     tracing::error!(
                         scope_key = %scope_key,
                         error = %err,
@@ -218,10 +228,18 @@ impl MemoryMaintenanceService {
                         json_candidate_preview = %preview_text(json_candidate, 400),
                         "Memory maintenance JSON decode failed"
                     );
-                AgentError::Other(format!("memory maintenance JSON decode error: {}", err))
-            })?;
+                    return Err(AgentError::Other(format!(
+                        "memory maintenance JSON decode error: {}",
+                        err
+                    )));
+                }
+            }
+        }
 
-        Ok(output)
+        Err(AgentError::Other(format!(
+            "memory organization failed after retries: {}",
+            last_error.unwrap_or_else(|| "unknown error".to_string())
+        )))
     }
 
     #[cfg_attr(not(test), allow(dead_code))]