baml-cc 0.208.5

data/lib/baml.rb

@@ -0,0 +1,63 @@
+begin
+  ruby_version = /(\d+\.\d+)/.match(RUBY_VERSION)
+  require_relative "baml/#{ruby_version}/ruby_ffi"
+rescue LoadError
+  require_relative "baml/ruby_ffi"
+end
+# require_relative "baml/ruby_ffi"
+require_relative "stream"
+require_relative "struct"
+require_relative "checked"
+
+module Baml
+  ClientRegistry = Baml::Ffi::ClientRegistry
+  Image = Baml::Ffi::Image
+  Audio = Baml::Ffi::Audio
+  Collector = Baml::Ffi::Collector
+
+  # Reexport Checked types.
+  Checked = Baml::Checks::Checked
+  Check = Baml::Checks::Check
+
+
+  # Dynamically + idempotently define Baml::TypeConverter
+  # NB: this does not respect raise_coercion_error = false
+  def self.convert_to(type)
+    if !Baml.const_defined?(:TypeConverter)
+      Baml.const_set(:TypeConverter, Class.new(TypeCoerce::Converter) do
+        def initialize(type)
+          super(type)
+        end
+        
+        def _convert(value, type, raise_coercion_error, coerce_empty_to_nil)
+          # make string handling more strict
+          if type == String
+            if value.is_a?(String)
+              return value
+            end
+
+            raise TypeCoerce::CoercionError.new(value, type)
+          end
+
+          # add unions
+          if type.is_a?(T::Types::Union)
+            type.types.each do |t|
+              # require raise_coercion_error on the recursive union call,
+              # so that we can suppress the error if it fails
+              converted = _convert(value, t, true, coerce_empty_to_nil)
+              return converted
+            rescue
+              # do nothing - try every instance of the union
+            end
+
+            raise TypeCoerce::CoercionError.new(value, type)
+          end
+
+          super(value, type, raise_coercion_error, coerce_empty_to_nil)
+        end
+      end)
+    end
+
+    Baml.const_get(:TypeConverter).new(type)
+  end
+end

data/lib/checked.rb

@@ -0,0 +1,36 @@
+require "sorbet-runtime"
+
+module Baml
+  module Checks
+
+    class Check < T::Struct
+      extend T::Sig
+
+      const :name, String
+      const :expr, String
+      const :status, String
+
+
+      def initialize(props)
+        super(name: props[:name], expr: props[:expr], status: props[:status])
+      end
+    end
+
+    class Checked < T::Struct
+      extend T::Sig
+
+      extend T::Generic
+
+      Value = type_member
+
+      const :value, Value
+      const :checks, T::Hash[Symbol, Check]
+
+      def initialize(props)
+        super(value: props[:value], checks: props[:checks])
+      end
+
+    end
+
+  end
+end

data/lib/stream.rb

@@ -0,0 +1,87 @@
+require "sorbet-runtime"
+
+module Baml
+  # class BamlStream
+  #   include Enumerable
+
+  #   def initialize(raw_stream:)
+  #     @raw_stream = raw_stream
+  #   end
+
+  #   def each(&block)
+  #     @raw_stream.each do |raw_msg|
+  #       yield Message.from(raw_msg)
+  #     end
+  #   end
+  # end
+
+  class StreamState < T::Struct
+    extend T::Sig
+
+    extend T::Generic
+
+    Value = type_member
+
+    const :value, Value
+    const :state, Symbol
+
+    def initialize(props)
+      super(value: props[:value], state: props[:state])
+    end
+
+  end
+
+  class BamlStream
+    extend T::Sig
+    extend T::Generic
+
+    include Enumerable
+
+    PartialType = type_member
+    FinalType = type_member
+
+    def initialize(
+      ffi_stream:,
+      ctx_manager:
+    )
+      @ffi_stream = ffi_stream
+      @ctx_manager = ctx_manager
+
+      @final_response = nil
+    end
+
+    # Calls the given block once for each event in the stream, where event is a parsed
+    # partial response. Returns `self` to enable chaining `.get_final_response`.
+    #
+    # Must be called with a block.
+    #
+    # @yieldparam [PartialType] event the parsed partial response
+    # @return [BamlStream] self
+    sig { params(block: T.proc.params(event: PartialType).void).returns(BamlStream)}
+    def each(&block)
+      # Implementing this and include-ing Enumerable allows users to treat this as a Ruby
+      # collection: https://ruby-doc.org/3.1.6/Enumerable.html#module-Enumerable-label-Usage
+      if @final_response == nil
+        @final_response = @ffi_stream.done(@ctx_manager) do |event|
+          block.call event.parsed_using_types(Baml::Types, Baml::PartialTypes, true)
+        end
+      end
+
+      self
+    end
+
+
+    # Gets the final response from the stream.
+    #
+    # @return [FinalType] the parsed final response
+    sig {returns(FinalType)}
+    def get_final_response
+      if @final_response == nil
+        @final_response = @ffi_stream.done(@ctx_manager)
+      end
+
+      @final_response.parsed_using_types(Baml::Types, Baml::PartialTypes, false)
+    end
+  end
+
+end

data/lib/struct.rb

@@ -0,0 +1,66 @@
+# This file should NOT be imported from baml.rb; we don't want
+# to introduce a hard dependency on Sorbet for the baml gem.
+require "ostruct"
+#require "pp"
+
+module Baml
+  module Sorbet
+    # Provides dynamic properties on statically defined classes
+    module Struct
+      # Needed to allow accessing dynamic types
+      def method_missing(symbol)
+        @props[symbol]
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          @props.eql?(other.instance_variable_get(:@args))
+      end
+
+      def hash
+        [self.class, @props].hash
+      end
+
+      def [](key)
+        key = key.to_sym if key.is_a?(String)
+        @props[key]
+      end
+
+      def inspect
+        PP.pp(self, +"", 79)
+      end
+
+      # https://docs.ruby-lang.org/en/master/PP.html
+      def pretty_print(pp)
+        pp.object_group(self) do
+          pp.breakable
+          @props.each do |key, value|
+            pp.text "#{key}="
+            pp.pp value
+            pp.comma_breakable unless key == @props.keys.last
+          end
+        end
+      end
+
+      # From the ostruct implementation
+      def to_h(&block)
+        if block
+          @props.map(&block).to_h
+        else
+          @props.dup
+        end
+      end
+
+      def to_json(*args)
+        @props.to_json(*args)
+      end
+    end
+  end
+
+  # Dynamically defined output classes are instantiated using this class
+  class DynamicStruct < OpenStruct
+    def to_json(*args)
+      @table.to_json(*args)
+    end
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: baml-cc
+version: !ruby/object:Gem::Version
+  version: 0.208.5
+platform: ruby
+authors:
+- BoundaryML
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-09-28 00:00:00.000000000 Z
+dependencies: []
+description: A gem for users to interact with BoundaryML's Language Model clients
+  (LLM) in Ruby.
+email:
+- contact@boundaryml.com
+executables:
+- baml-cli
+- baml
+extensions:
+- ext/ruby_ffi/extconf.rb
+extra_rdoc_files: []
+files:
+- exe/baml
+- exe/baml-cli
+- ext/ruby_ffi/Cargo.toml
+- ext/ruby_ffi/build.rs
+- ext/ruby_ffi/extconf.rb
+- ext/ruby_ffi/src/function_result.rs
+- ext/ruby_ffi/src/function_result_stream.rs
+- ext/ruby_ffi/src/lib.rs
+- ext/ruby_ffi/src/ruby_to_json.rs
+- ext/ruby_ffi/src/types/client_registry.rs
+- ext/ruby_ffi/src/types/lang_wrapper.rs
+- ext/ruby_ffi/src/types/log_collector.rs
+- ext/ruby_ffi/src/types/media.rs
+- ext/ruby_ffi/src/types/mod.rs
+- ext/ruby_ffi/src/types/request.rs
+- ext/ruby_ffi/src/types/response.rs
+- ext/ruby_ffi/src/types/runtime_ctx_manager.rs
+- ext/ruby_ffi/src/types/type_builder.rs
+- lib/baml.rb
+- lib/checked.rb
+- lib/stream.rb
+- lib/struct.rb
+homepage: https://github.com/BoundaryML/baml
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: Unified BoundaryML LLM client
+test_files: []