Fetch API (#1916)

<!-- ELLIPSIS_HIDDEN -->


> [!IMPORTANT]
> Introduces `fetch_value` built-in function for HTTP GET requests in
BAML, with parsing, type checking, and evaluation support.
> 
>   - **Behavior**:
> - Adds `fetch_value` built-in function in
`baml-core/src/ir/builtin.rs` to perform HTTP GET requests.
>     - Parses response into specified type using `jsonish` library.
> - Supports only GET method with `base_url`, `headers`, and
`query_params`.
>   - **Parsing**:
> - Updates `parse_expr.rs` and `parse_expression.rs` to handle generic
function applications.
> - Adds `App` struct in `ast/app.rs` to represent function applications
with type arguments.
>   - **Type Checking**:
> - Modifies `expr_typecheck.rs` to include type checking for
`fetch_value`.
>     - Ensures type arguments are provided for generic functions.
>   - **Evaluation**:
> - Implements evaluation logic in `eval_expr.rs` to execute HTTP
requests and parse responses.
> - Handles proxy URL and API key injection in `fiddle-proxy/server.js`.
>   - **Testing**:
> - Adds tests in `validation_files/expr/builtin.baml` and
`constructors_invalid.baml` to validate new functionality.
>   - **Misc**:
> - Updates `field_type/mod.rs` and `field_type/builder.rs` to support
new types and methods.
> 
> <sup>This description was created by </sup>[<img alt="Ellipsis"
src="https://img.shields.io/badge/Ellipsis-blue?color=175173">](https://www.ellipsis.dev?ref=BoundaryML%2Fbaml&utm_source=github&utm_medium=referral)<sup>
for 4f15177. You can
[customize](https://app.ellipsis.dev/BoundaryML/settings/summaries) this
summary. It will automatically update as commits are pushed.</sup>


<!-- ELLIPSIS_HIDDEN -->

---------

Co-authored-by: Greg Hale <imalsogreg@gmail.com>

Author: antoniosarosi

engine/baml-lib/baml-core/src/ir/builtin.rs

@@ -0,0 +1,138 @@
+use super::repr::{Class, Enum, EnumValue, ExprFunction, Field, Node, NodeAttributes};
+use crate::{ir::repr::IntermediateRepr, Configuration};
+use baml_types::{
+    expr::{Builtin, Expr, ExprMetadata},
+    Arrow, FieldType,
+};
+use internal_baml_diagnostics::Span;
+
+pub mod functions {
+    pub const FETCH_VALUE: &str = "std::fetch_value";
+}
+
+pub mod classes {
+    pub const REQUEST: &str = "std::Request";
+}
+
+pub mod enums {
+    pub const HTTP_METHOD: &str = "std::HttpMethod";
+}
+
+/// Builtins are exposed through a separate IR, which can be combined with
+/// the user's IR via `IntermediateRepr::extend`.
+pub fn builtin_ir() -> IntermediateRepr {
+    IntermediateRepr {
+        enums: builtin_enums(),
+        classes: builtin_classes(),
+        type_aliases: vec![],
+        functions: vec![],
+        expr_fns: vec![],
+        toplevel_assignments: vec![],
+        clients: vec![],
+        retry_policies: vec![],
+        template_strings: vec![],
+        finite_recursive_cycles: vec![],
+        structural_recursive_alias_cycles: vec![],
+        configuration: Configuration::default(),
+    }
+}
+
+fn builtin<T, const N: usize>(elems: [T; N]) -> Vec<Node<T>> {
+    let mut attributes = NodeAttributes::default();
+    attributes.span = Some(Span::fake());
+
+    Vec::from_iter(elems.into_iter().map(|e| Node {
+        attributes: NodeAttributes::default(),
+        elem: e,
+    }))
+}
+
+pub fn builtin_classes() -> Vec<Node<Class>> {
+    builtin([Class {
+        name: String::from(classes::REQUEST),
+        docstring: None,
+        static_fields: vec![
+            // Node {
+            //     attributes: NodeAttributes::default(),
+            //     elem: Field {
+            //         name: String::from("method"),
+            //         r#type: Node {
+            //             elem: FieldType::r#enum(enums::HTTP_METHOD),
+            //             attributes: NodeAttributes::default(),
+            //         },
+            //         docstring: None,
+            //     },
+            // },
+            Node {
+                attributes: NodeAttributes::default(),
+                elem: Field {
+                    name: String::from("base_url"),
+                    r#type: Node {
+                        elem: FieldType::string(),
+                        attributes: NodeAttributes::default(),
+                    },
+                    docstring: None,
+                },
+            },
+            Node {
+                attributes: NodeAttributes::default(),
+                elem: Field {
+                    name: String::from("headers"),
+                    r#type: Node {
+                        elem: FieldType::map(FieldType::string(), FieldType::string()),
+                        attributes: NodeAttributes::default(),
+                    },
+                    docstring: None,
+                },
+            },
+            Node {
+                attributes: NodeAttributes::default(),
+                elem: Field {
+                    name: String::from("query_params"),
+                    r#type: Node {
+                        elem: FieldType::map(FieldType::string(), FieldType::string()),
+                        attributes: NodeAttributes::default(),
+                    },
+                    docstring: None,
+                },
+            },
+        ],
+        inputs: vec![],
+    }])
+}
+
+pub fn builtin_enums() -> Vec<Node<Enum>> {
+    builtin([Enum {
+        name: String::from(enums::HTTP_METHOD),
+        docstring: None,
+        values: vec![(
+            Node {
+                attributes: NodeAttributes::default(),
+                elem: EnumValue(String::from("Get")),
+            },
+            None,
+        )],
+    }])
+}
+
+/// This builds a specialized version of an std generic function.
+///
+/// For now we only have functions that take in a generic type parameter and
+/// return that same type, generics do not appear in function parameters. So
+/// managing this is fairly simple, but will require carrying additional data
+/// when actual user defined generics are introduced.
+pub fn builtin_generic_fn(f: Builtin, return_type: FieldType) -> Expr<ExprMetadata> {
+    let signature = match f {
+        // fn fetch_value<T>(request: std::Request) -> T
+        Builtin::FetchValue => Arrow {
+            param_types: vec![FieldType::class(classes::REQUEST)],
+            return_type,
+        },
+    };
+
+    Expr::Builtin(f, (Span::fake(), Some(FieldType::arrow(signature))))
+}
+
+pub fn is_builtin_identifier(identifier: &str) -> bool {
+    identifier.starts_with("std::")
+}

engine/baml-lib/baml-core/src/ir/ir_helpers/mod.rs

@@ -195,7 +195,6 @@ pub trait IRHelperExtended: IRSemanticStreamingHelper {
             (FieldType::Tuple(_), _) => false,
             (FieldType::Enum(_), _) => false,
             (FieldType::Class(_), _) => false,
-
             (FieldType::Arrow(arrow1), FieldType::Arrow(arrow2)) => {
                 let param_lengths_match = arrow1.param_types.len() == arrow2.param_types.len();
                 // N.B. Functions are covariant in their return type and contravariant in their arguments.

engine/baml-lib/baml-core/src/ir/json_schema.rs

@@ -204,7 +204,7 @@ impl WithJsonSchema for FieldType {
                     schema["default"] = serde_json::Value::Null;
                 }
                 schema
-            },
+            }
             // Handle map types with optional support
             // For example: map<string, int>? generates a schema that allows both object and null
             FieldType::Map(_k, v) => {
@@ -222,7 +222,7 @@ impl WithJsonSchema for FieldType {
                     schema["default"] = serde_json::Value::Null;
                 }
                 schema
-            },
+            }
             FieldType::Union(options) => json!({
                 "anyOf": options.iter().map(|t| {
                     let mut res = t.json_schema();
@@ -263,7 +263,8 @@ impl WithJsonSchema for FieldType {
                 }
             }
             FieldType::WithMetadata { base, .. } => base.json_schema(),
-            FieldType::Arrow(_) => json!({}), // TODO: Make this function partial - it should not return for Arrow.
+            // TODO: Make this function partial - it should not return for these variants.
+            FieldType::Arrow(_) => json!({}),
         }
     }
 }

engine/baml-lib/baml-core/src/ir/mod.rs

@@ -1,3 +1,4 @@
+pub mod builtin;
 pub mod ir_hasher;
 pub mod ir_helpers;
 pub mod jinja_helpers;