get some stuff for go and streaming working

Author: hellovai

engine/baml-lib/baml-types/src/baml_value.rs

@@ -367,6 +367,12 @@ impl<T: crate::HasFieldType> crate::HasFieldType for BamlValueWithMeta<T> {
     }
 }
 
+impl<T: crate::HasCompletion> crate::HasCompletion for BamlValueWithMeta<T> {
+    fn completion(&self) -> &crate::Completion {
+        self.meta().completion()
+    }
+}
+
 impl<T> BamlValueWithMeta<T> {
     pub fn r#type(&self) -> String {
         let plain_value: BamlValue = self.into();
@@ -928,6 +934,10 @@ pub struct Completion {
     pub required_done: bool,
 }
 
+pub trait HasCompletion {
+    fn completion(&self) -> &Completion;
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize)]
 pub enum CompletionState {
     Pending,

engine/baml-lib/baml-types/src/lib.rs

@@ -11,7 +11,7 @@ mod field_type;
 mod generator;
 mod value_expr;
 
-pub use baml_value::{BamlValue, BamlValueWithMeta, Completion, CompletionState};
+pub use baml_value::{BamlValue, BamlValueWithMeta, Completion, CompletionState, HasCompletion};
 pub use constraint::*;
 pub use field_type::{
     Arrow, FieldType, HasFieldType, LiteralValue, StreamingBehavior, ToUnionName, TypeValue,

engine/baml-lib/jsonish/src/lib.rs

@@ -49,6 +49,12 @@ impl baml_types::HasFieldType for ResponseValueMeta {
     }
 }
 
+impl baml_types::HasCompletion for ResponseValueMeta {
+    fn completion(&self) -> &Completion {
+        &self.2
+    }
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub enum SerializeMode {
     Final,

engine/language_client_cffi/Makefile.toml

@@ -46,6 +46,10 @@ dependencies = ["build-go-cli"]
 script = "cd ../../integ-tests/go && go build"
 dependencies = ["integ-tests-generate"]
 
+[tasks.integ-tests-run]
+script = "cd ../../integ-tests/go && BAML_LIBRARY_PATH=../../engine/target/debug/libbaml_cffi.dylib ./integ-tests"
+dependencies = ["integ-tests-build"]
+
 #-----------------------------------------------------------------------------
 # Main tasks
 #-----------------------------------------------------------------------------

engine/language_client_cffi/src/cffi/cffi_generated.rs

@@ -672,6 +672,120 @@ impl<'a> flatbuffers::Verifiable for CFFIStreamState {
 }
 
 impl flatbuffers::SimpleToVerifyInSlice for CFFIStreamState {}
+pub enum CFFITypeNameOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct CFFITypeName<'a> {
+  pub _tab: flatbuffers::Table<'a>,
+}
+
+impl<'a> flatbuffers::Follow<'a> for CFFITypeName<'a> {
+  type Inner = CFFITypeName<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: flatbuffers::Table::new(buf, loc) }
+  }
+}
+
+impl<'a> CFFITypeName<'a> {
+  pub const VT_NAMESPACE: flatbuffers::VOffsetT = 4;
+  pub const VT_NAME: flatbuffers::VOffsetT = 6;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    CFFITypeName { _tab: table }
+  }
+  #[allow(unused_mut)]
+  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
+    _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
+    args: &'args CFFITypeNameArgs<'args>
+  ) -> flatbuffers::WIPOffset<CFFITypeName<'bldr>> {
+    let mut builder = CFFITypeNameBuilder::new(_fbb);
+    if let Some(x) = args.name { builder.add_name(x); }
+    if let Some(x) = args.namespace { builder.add_namespace(x); }
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn namespace(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(CFFITypeName::VT_NAMESPACE, None)}
+  }
+  #[inline]
+  pub fn name(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(CFFITypeName::VT_NAME, None)}
+  }
+}
+
+impl flatbuffers::Verifiable for CFFITypeName<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut flatbuffers::Verifier, pos: usize
+  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
+    use self::flatbuffers::Verifiable;
+    v.visit_table(pos)?
+     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("namespace", Self::VT_NAMESPACE, false)?
+     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct CFFITypeNameArgs<'a> {
+    pub namespace: Option<flatbuffers::WIPOffset<&'a str>>,
+    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
+}
+impl<'a> Default for CFFITypeNameArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    CFFITypeNameArgs {
+      namespace: None,
+      name: None,
+    }
+  }
+}
+
+pub struct CFFITypeNameBuilder<'a: 'b, 'b> {
+  fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
+  start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+}
+impl<'a: 'b, 'b> CFFITypeNameBuilder<'a, 'b> {
+  #[inline]
+  pub fn add_namespace(&mut self, namespace: flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(CFFITypeName::VT_NAMESPACE, namespace);
+  }
+  #[inline]
+  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(CFFITypeName::VT_NAME, name);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CFFITypeNameBuilder<'a, 'b> {
+    let start = _fbb.start_table();
+    CFFITypeNameBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> flatbuffers::WIPOffset<CFFITypeName<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl core::fmt::Debug for CFFITypeName<'_> {
+  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    let mut ds = f.debug_struct("CFFITypeName");
+      ds.field("namespace", &self.namespace());
+      ds.field("name", &self.name());
+      ds.finish()
+  }
+}
 pub enum CFFIValueHolderOffset {}
 #[derive(Copy, Clone, PartialEq)]
 
@@ -1884,11 +1998,11 @@ impl<'a> CFFIValueClass<'a> {
 
 
   #[inline]
-  pub fn name(&self) -> Option<&'a str> {
+  pub fn name(&self) -> Option<CFFITypeName<'a>> {
     // Safety:
     // Created from valid Table for this object
     // which contains a valid value in this slot
-    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(CFFIValueClass::VT_NAME, None)}
+    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<CFFITypeName>>(CFFIValueClass::VT_NAME, None)}
   }
   #[inline]
   pub fn fields(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<CFFIMapEntry<'a>>>> {
@@ -1913,15 +2027,15 @@ impl flatbuffers::Verifiable for CFFIValueClass<'_> {
   ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
     use self::flatbuffers::Verifiable;
     v.visit_table(pos)?
-     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
+     .visit_field::<flatbuffers::ForwardsUOffset<CFFITypeName>>("name", Self::VT_NAME, false)?
      .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<CFFIMapEntry>>>>("fields", Self::VT_FIELDS, false)?
      .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<CFFIMapEntry>>>>("dynamic_fields", Self::VT_DYNAMIC_FIELDS, false)?
      .finish();
     Ok(())
   }
 }
 pub struct CFFIValueClassArgs<'a> {
-    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
+    pub name: Option<flatbuffers::WIPOffset<CFFITypeName<'a>>>,
     pub fields: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<CFFIMapEntry<'a>>>>>,
     pub dynamic_fields: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<CFFIMapEntry<'a>>>>>,
 }
@@ -1942,8 +2056,8 @@ pub struct CFFIValueClassBuilder<'a: 'b, 'b> {
 }
 impl<'a: 'b, 'b> CFFIValueClassBuilder<'a, 'b> {
   #[inline]
-  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
-    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(CFFIValueClass::VT_NAME, name);
+  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<CFFITypeName<'b >>) {
+    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<CFFITypeName>>(CFFIValueClass::VT_NAME, name);
   }
   #[inline]
   pub fn add_fields(&mut self, fields: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<CFFIMapEntry<'b >>>>) {
@@ -2015,11 +2129,11 @@ impl<'a> CFFIValueEnum<'a> {
 
 
   #[inline]
-  pub fn name(&self) -> Option<&'a str> {
+  pub fn name(&self) -> Option<CFFITypeName<'a>> {
     // Safety:
     // Created from valid Table for this object
     // which contains a valid value in this slot
-    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(CFFIValueEnum::VT_NAME, None)}
+    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<CFFITypeName>>(CFFIValueEnum::VT_NAME, None)}
   }
   #[inline]
   pub fn value(&self) -> Option<&'a str> {
@@ -2044,15 +2158,15 @@ impl flatbuffers::Verifiable for CFFIValueEnum<'_> {
   ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
     use self::flatbuffers::Verifiable;
     v.visit_table(pos)?
-     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
+     .visit_field::<flatbuffers::ForwardsUOffset<CFFITypeName>>("name", Self::VT_NAME, false)?
      .visit_field::<flatbuffers::ForwardsUOffset<&str>>("value", Self::VT_VALUE, false)?
      .visit_field::<bool>("is_dynamic", Self::VT_IS_DYNAMIC, false)?
      .finish();
     Ok(())
   }
 }
 pub struct CFFIValueEnumArgs<'a> {
-    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
+    pub name: Option<flatbuffers::WIPOffset<CFFITypeName<'a>>>,
     pub value: Option<flatbuffers::WIPOffset<&'a str>>,
     pub is_dynamic: bool,
 }
@@ -2073,8 +2187,8 @@ pub struct CFFIValueEnumBuilder<'a: 'b, 'b> {
 }
 impl<'a: 'b, 'b> CFFIValueEnumBuilder<'a, 'b> {
   #[inline]
-  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
-    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(CFFIValueEnum::VT_NAME, name);
+  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<CFFITypeName<'b >>) {
+    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<CFFITypeName>>(CFFIValueEnum::VT_NAME, name);
   }
   #[inline]
   pub fn add_value(&mut self, value: flatbuffers::WIPOffset<&'b  str>) {
@@ -2361,11 +2475,11 @@ impl<'a> CFFIValueUnionVariant<'a> {
 
 
   #[inline]
-  pub fn name(&self) -> Option<&'a str> {
+  pub fn name(&self) -> Option<CFFITypeName<'a>> {
     // Safety:
     // Created from valid Table for this object
     // which contains a valid value in this slot
-    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(CFFIValueUnionVariant::VT_NAME, None)}
+    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<CFFITypeName>>(CFFIValueUnionVariant::VT_NAME, None)}
   }
   #[inline]
   pub fn variant_name(&self) -> Option<&'a str> {
@@ -2404,7 +2518,7 @@ impl flatbuffers::Verifiable for CFFIValueUnionVariant<'_> {
   ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
     use self::flatbuffers::Verifiable;
     v.visit_table(pos)?
-     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
+     .visit_field::<flatbuffers::ForwardsUOffset<CFFITypeName>>("name", Self::VT_NAME, false)?
      .visit_field::<flatbuffers::ForwardsUOffset<&str>>("variant_name", Self::VT_VARIANT_NAME, false)?
      .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<CFFIFieldTypeHolder>>>>("field_types", Self::VT_FIELD_TYPES, false)?
      .visit_field::<i32>("value_type_index", Self::VT_VALUE_TYPE_INDEX, false)?
@@ -2414,7 +2528,7 @@ impl flatbuffers::Verifiable for CFFIValueUnionVariant<'_> {
   }
 }
 pub struct CFFIValueUnionVariantArgs<'a> {
-    pub name: Option<flatbuffers::WIPOffset<&'a str>>,
+    pub name: Option<flatbuffers::WIPOffset<CFFITypeName<'a>>>,
     pub variant_name: Option<flatbuffers::WIPOffset<&'a str>>,
     pub field_types: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<CFFIFieldTypeHolder<'a>>>>>,
     pub value_type_index: i32,
@@ -2439,8 +2553,8 @@ pub struct CFFIValueUnionVariantBuilder<'a: 'b, 'b> {
 }
 impl<'a: 'b, 'b> CFFIValueUnionVariantBuilder<'a, 'b> {
   #[inline]
-  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b  str>) {
-    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(CFFIValueUnionVariant::VT_NAME, name);
+  pub fn add_name(&mut self, name: flatbuffers::WIPOffset<CFFITypeName<'b >>) {
+    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<CFFITypeName>>(CFFIValueUnionVariant::VT_NAME, name);
   }
   #[inline]
   pub fn add_variant_name(&mut self, variant_name: flatbuffers::WIPOffset<&'b  str>) {