implement typed rethrows for higher-order functions

baml_language/crates/baml_builtins2/baml_std/testing/registry.baml

@@ -4,13 +4,13 @@
 
 class TestRegistration {
   name string
-  body () -> null
+  body () -> null throws unknown
   runner TestRunner?
 }
 
 class TestSetRegistration {
   name string
-  collector (TestCollector) -> null
+  collector (TestCollector) -> null throws unknown
   runner TestSetRunner?
 }
 

baml_language/crates/baml_compiler2_ast/src/ast.rs

@@ -97,10 +97,11 @@ pub enum TypeExpr {
         value: baml_base::Literal,
         attrs: Vec<RawAttribute>,
     },
-    /// Function type: (params) -> return
+    /// Function type: (params) -> return [throws E]
     Function {
         params: Vec<FunctionTypeParam>,
         ret: Box<TypeExpr>,
+        throws: Option<Box<TypeExpr>>,
         attrs: Vec<RawAttribute>,
     },
     /// The `unknown` keyword type

baml_language/crates/baml_compiler2_ast/src/disambiguate.rs

@@ -138,11 +138,19 @@ fn validate_type_expr_tree(expr: &TypeExpr, diagnostics: &mut Vec<(String, text_
                 validate_type_expr_tree(v, diagnostics);
             }
         }
-        TypeExpr::Function { params, ret, .. } => {
+        TypeExpr::Function {
+            params,
+            ret,
+            throws,
+            ..
+        } => {
             for p in params {
                 validate_type_expr_tree(&p.ty, diagnostics);
             }
             validate_type_expr_tree(ret, diagnostics);
+            if let Some(throws) = throws {
+                validate_type_expr_tree(throws, diagnostics);
+            }
         }
         _ => {}
     }

baml_language/crates/baml_compiler2_ast/src/lib.rs

@@ -178,7 +178,12 @@ mod tests {
                 value: value.clone(),
                 attrs: strip_attrs(attrs),
             },
-            TypeExpr::Function { params, ret, attrs } => TypeExpr::Function {
+            TypeExpr::Function {
+                params,
+                ret,
+                throws,
+                attrs,
+            } => TypeExpr::Function {
                 params: params
                     .iter()
                     .map(|p| crate::ast::FunctionTypeParam {
@@ -187,6 +192,7 @@ mod tests {
                     })
                     .collect(),
                 ret: Box::new(strip_spans(ret)),
+                throws: throws.as_ref().map(|t| Box::new(strip_spans(t))),
                 attrs: strip_attrs(attrs),
             },
             TypeExpr::Media { kind, attrs } => TypeExpr::Media {

baml_language/crates/baml_compiler2_ast/src/lower_type_expr.rs

@@ -164,9 +164,16 @@ fn lower_base_terminal(type_expr: &CstTypeExpr) -> TypeExpr {
             .function_return_type()
             .map(|t| lower_type_expr_inner(&t, false))
             .unwrap_or(TypeExpr::Unknown { attrs: vec![] });
+        let throws = type_expr.function_throws_type().map(|throws_clause| {
+            let throws_type = throws_clause
+                .type_expr()
+                .expect("THROWS_CLAUSE should have a type");
+            Box::new(lower_type_expr_inner(&throws_type, false))
+        });
         return TypeExpr::Function {
             params,
             ret: Box::new(ret),
+            throws,
             attrs: vec![],
         };
     }

baml_language/crates/baml_compiler2_mir/src/lower.rs

@@ -164,15 +164,28 @@ pub fn convert_tir2_ty(ty: &Tir2Ty, resolved: &ResolvedAliases) -> Ty {
             attr: attr.clone(),
         },
 
-        // Functions — drop param names
-        Tir2Ty::Function { params, ret, attr } => Ty::Function {
-            params: params
-                .iter()
-                .map(|(_, t)| convert_tir2_ty(t, resolved))
-                .collect(),
-            ret: Box::new(convert_tir2_ty(ret, resolved)),
-            attr: attr.clone(),
-        },
+        // Functions — drop param names; map Never throws to None
+        Tir2Ty::Function {
+            params,
+            ret,
+            throws,
+            attr,
+        } => {
+            let converted_throws = convert_tir2_ty(throws, resolved);
+            Ty::Function {
+                params: params
+                    .iter()
+                    .map(|(_, t)| convert_tir2_ty(t, resolved))
+                    .collect(),
+                ret: Box::new(convert_tir2_ty(ret, resolved)),
+                throws: if matches!(converted_throws, Ty::Void { .. }) {
+                    None
+                } else {
+                    Some(Box::new(converted_throws))
+                },
+                attr: attr.clone(),
+            }
+        }
 
         // Bottom / sentinel types
         Tir2Ty::Never { attr } => Ty::Void { attr: attr.clone() },