feat(config): parse model token limits from ACL

Author: Lixtt

core/src/config/loader.rs

@@ -52,6 +52,10 @@ fn acl_usize_attr(block: &a3s_acl::Block, keys: &[&str]) -> Option<usize> {
     }
 }
 
+fn acl_u32_attr(block: &a3s_acl::Block, keys: &[&str]) -> Option<u32> {
+    acl_usize_attr(block, keys).map(|value| value.min(u32::MAX as usize) as u32)
+}
+
 fn acl_path_list_attr(block: &a3s_acl::Block, keys: &[&str]) -> Option<Vec<PathBuf>> {
     let value = acl_attr(block, keys)?;
     match value {
@@ -276,10 +280,55 @@ impl CodeConfig {
                                             model.release_date = Some(release_date);
                                         }
                                     }
+                                    "maxTokens" | "max_tokens" | "outputTokens"
+                                    | "output_tokens" => {
+                                        if let Some(output) = acl_u32_attr(
+                                            model_block,
+                                            &[
+                                                "maxTokens",
+                                                "max_tokens",
+                                                "outputTokens",
+                                                "output_tokens",
+                                            ],
+                                        ) {
+                                            model.limit.output = output;
+                                        }
+                                    }
+                                    "contextTokens" | "context_tokens" | "maxContextTokens"
+                                    | "max_context_tokens" => {
+                                        if let Some(context) = acl_u32_attr(
+                                            model_block,
+                                            &[
+                                                "contextTokens",
+                                                "context_tokens",
+                                                "maxContextTokens",
+                                                "max_context_tokens",
+                                            ],
+                                        ) {
+                                            model.limit.context = context;
+                                        }
+                                    }
                                     _ => {}
                                 }
                             }
 
+                            for limit_block in &model_block.blocks {
+                                if limit_block.name == "limit" {
+                                    if let Some(output) = acl_u32_attr(
+                                        limit_block,
+                                        &["output", "max_tokens", "output_tokens"],
+                                    ) {
+                                        model.limit.output = output;
+                                    }
+                                    if let Some(context) = acl_u32_attr(
+                                        limit_block,
+                                        &["context", "context_tokens", "max_context_tokens"],
+                                    ) {
+                                        model.limit.context = context;
+                                    }
+                                }
+                            }
+
                             provider.models.push(model);
                         }
                     }

core/src/config/tests.rs

@@ -111,6 +111,40 @@ fn test_config_supports_acl_style_provider_labels() {
     assert!(config.providers[0].models[0].tool_call);
 }
 
+#[test]
+fn test_config_parses_acl_model_token_limits() {
+    let config = CodeConfig::from_acl(
+        r#"
+            default_model = "openai/glm-5.1"
+
+            providers "openai" {
+              api_key = "sk-test"
+              base_url = "http://127.0.0.1:18051/v1"
+
+              models "glm-5.1" {
+                name = "GLM 5.1"
+                max_tokens = 4096
+                context_tokens = 32768
+              }
+
+              models "camel-aliases" {
+                outputTokens = 8192
+                maxContextTokens = 65536
+              }
+            }
+        "#,
+    )
+    .unwrap();
+
+    let flat = &config.providers[0].models[0].limit;
+    assert_eq!(flat.output, 4096);
+    assert_eq!(flat.context, 32768);
+
+    let aliases = &config.providers[0].models[1].limit;
+    assert_eq!(aliases.output, 8192);
+    assert_eq!(aliases.context, 65536);
+}
+
 #[test]
 fn test_config_builder() {
     let config = CodeConfig::new()