llmtrim 0.5.0-x86_64-linux → 0.6.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d2e301e24e9662b07fdfbe23173c9484fdca41eaeb42c181aa3f7a29e256988
-  data.tar.gz: 8ab5ef43f57d2653299b5900b7ac1c8e46312729710ba7d5b4c0c117c4be5876
+  metadata.gz: 5173a07ebbc309c7874ccc3f98cec214c045cbc16a80656de03541a2cd0cbce5
+  data.tar.gz: c052c591279898c45f14c7abcf6028966f58b0f9e82c5656723f0b2eb9fc2217
 SHA512:
-  metadata.gz: 3159228c3ea53491077c1c9f9207e7af254db11d88e78f164332b648029ce33ffa9cfa602a549dafd0abd3b4d049db90dd786e84d34ed622b87402d568ff2945
-  data.tar.gz: 22c6651c3067f4640f72c01bbe769a0d1df0e408e1e6ee6312b8de31cf51debfdc28483979bcc22ce50ff7fe15f95c999084e46a4672c0b9d14ef3536750f828
+  metadata.gz: fb9af7cfe197be47bbc91ce29124d2b3c7ec4b5bf852eb21b6f1267bfdf36e1671096e91c7c8610dddf5c06b16113f9b1271d205ce806a0c600e0918a7947230
+  data.tar.gz: e7b6f0a245c6549e644f18b4e02ea0243e913f1c35b3e00df3a7f9a8f3834760b11ea3857678ccea8fa17ce0bb679dad45f18e495de890beca1939cc2cb9ce23

data/lib/llmtrim/llmtrim_ffi.rb

@@ -14,7 +14,7 @@
 # helpers directly inline like we're doing here.
 
 require 'ffi'
-
+require 'set'
 
 module LlmtrimFfi
   def self.uniffi_in_range(i, type_name, min, max)
@@ -36,21 +36,64 @@ def self.uniffi_bytes(v)
   v.to_str
 end
 
+# Callback return codes
+UNIFFI_CALLBACK_SUCCESS = 0
+UNIFFI_CALLBACK_ERROR = 1
+UNIFFI_CALLBACK_UNEXPECTED_ERROR = 2
+
+# Call a method on a callback interface object, catching and reporting errors
+# to Rust via the call_status.
+# If error_type is provided, known errors of that type are reported as UNIFFI_CALLBACK_ERROR;
+# all other errors are reported as UNIFFI_CALLBACK_UNEXPECTED_ERROR.
+def self.uniffi_trait_interface_call(call_status, make_call, write_return_value, error_type = nil, lower_error = nil)
+  begin
+    write_return_value.call make_call.call
+  rescue StandardError => e
+    buf = if !error_type.nil? && uniffi_is_error_type?(e, error_type)
+      call_status[:code] = UNIFFI_CALLBACK_ERROR
+      lower_error.call e
+    else
+      call_status[:code] = UNIFFI_CALLBACK_UNEXPECTED_ERROR
+      RustBuffer.alloc_from_string(e.inspect)
+    end
+
+    error_buf = call_status[:error_buf]
+    error_buf[:capacity] = buf[:capacity]
+    error_buf[:len] = buf[:len]
+    error_buf[:data] = buf[:data]
+  end
+end
+
+# Check if an exception is a variant of the given error type.
+# Error types in Ruby are either modules (non-flat enums) or classes (flat enums),
+# with variant classes as constant within them.
+def self.uniffi_is_error_type?(e, error_type)
+  # Object-as-error: error_type is a class itself (e.g. MyError < StandardError)
+  if error_type.is_a?(Class) && e.is_a?(error_type)
+    return true
+  end
+
+  # Enum error: error_type is a module with class constants for each variant
+  error_type.constants.any? do |c|
+    klass = error_type.const_get c
+    klass.is_a?(Class) && e.is_a?(klass)
+  end
+end
   class RustBuffer < FFI::Struct
   layout :capacity, :uint64,
          :len,      :uint64,
          :data,     :pointer
 
   def self.alloc(size)
-    return LlmtrimFfi.rust_call(:ffi_llmtrim_ffi_rustbuffer_alloc, size)
+    return ::LlmtrimFfi.rust_call(:ffi_llmtrim_ffi_rustbuffer_alloc, size)
   end
 
   def self.reserve(rbuf, additional)
-    return LlmtrimFfi.rust_call(:ffi_llmtrim_ffi_rustbuffer_reserve, rbuf, additional)
+    return ::LlmtrimFfi.rust_call(:ffi_llmtrim_ffi_rustbuffer_reserve, rbuf, additional)
   end
 
   def free
-    LlmtrimFfi.rust_call(:ffi_llmtrim_ffi_rustbuffer_free, self)
+    ::LlmtrimFfi.rust_call(:ffi_llmtrim_ffi_rustbuffer_free, self)
   end
 
   def capacity
@@ -98,14 +141,14 @@ end
     free
   end# The primitive String type.
 
-  def self.allocFromString(value)
+  def self.alloc_from_string(value)
     RustBuffer.allocWithBuilder do |builder|
       builder.write value.encode('utf-8')
       return builder.finalize
     end
   end
 
-  def consumeIntoString
+  def consume_into_string
     consumeWithStream do |stream|
       return stream.read(stream.remaining).force_encoding(Encoding::UTF_8)
     end
@@ -133,9 +176,9 @@ end
     end
   end
 
-  def consumeIntoTypeCompressOutput
+  def consume_into_TypeCompressOutput
     consumeWithStream do |stream|
-      return stream.readTypeCompressOutput
+      return stream.read_TypeCompressOutput
     end
   end
 
@@ -156,12 +199,26 @@ end
     end
   end
 
-  def consumeIntoTypeStageReport
+  def consume_into_TypeStageReport
     consumeWithStream do |stream|
-      return stream.readTypeStageReport
+      return stream.read_TypeStageReport
+    end
+  end
+
+  # Error enum - generate alloc_from for callback error serialization
+  def self.alloc_from_TypeLlmtrimError(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeLlmtrimError(v)
+      return builder.finalize
     end
   end
 
+  # Enum used as error - generate consume_into_ for use as a return value
+  def consume_into_TypeLlmtrimError
+    consumeWithStream do |stream|
+      return stream.read_TypeLlmtrimError
+    end
+  end
   
 
   # The Enum type Provider.
@@ -176,9 +233,9 @@ end
     end
   end
 
-  def consumeIntoTypeProvider
+  def consume_into_TypeProvider
     consumeWithStream do |stream|
-      return stream.readTypeProvider
+      return stream.read_TypeProvider
     end
   end
   
@@ -186,7 +243,7 @@ end
   # The Optional<T> type for string.
 
   def self.check_lower_Optionalstring(v)
-    if not v.nil?
+    if !v.nil?
       
     end
   end
@@ -198,16 +255,16 @@ end
     end
   end
 
-  def consumeIntoOptionalstring
+  def consume_into_Optionalstring
     consumeWithStream do |stream|
-      return stream.readOptionalstring
+      return stream.read_Optionalstring
     end
   end
 
   # The Optional<T> type for TypeProvider.
 
   def self.check_lower_OptionalTypeProvider(v)
-    if not v.nil?
+    if !v.nil?
       RustBuffer.check_lower_TypeProvider(v)
     end
   end
@@ -219,9 +276,9 @@ end
     end
   end
 
-  def consumeIntoOptionalTypeProvider
+  def consume_into_OptionalTypeProvider
     consumeWithStream do |stream|
-      return stream.readOptionalTypeProvider
+      return stream.read_OptionalTypeProvider
     end
   end
 
@@ -240,9 +297,9 @@ end
     end
   end
 
-  def consumeIntoSequenceTypeStageReport
+  def consume_into_SequenceTypeStageReport
     consumeWithStream do |stream|
-      return stream.readSequenceTypeStageReport
+      return stream.read_SequenceTypeStageReport
     end
   end
 
@@ -292,11 +349,11 @@ class RustBufferStream
     data
   end
 
-  def readU64
+  def read_u64
     unpack_from 8, 'Q>'
   end
 
-  def readBool
+  def read_bool
     v = unpack_from 1, 'c'
 
     return false if v == 0
@@ -305,7 +362,7 @@ class RustBufferStream
     raise InternalError, 'Unexpected byte for Boolean type'
   end
 
-  def readString
+  def read_string
     size = unpack_from 4, 'l>'
 
     raise InternalError, 'Unexpected negative string length' if size.negative?
@@ -315,30 +372,30 @@ class RustBufferStream
 
   # The Record type CompressOutput.
 
-  def readTypeCompressOutput
+  def read_TypeCompressOutput
     CompressOutput.new(
-      request_json: readString,
-      provider: readString,
-      model: readOptionalstring,
-      tokenizer_label: readString,
-      tokenizer_exact: readBool,
-      input_tokens_before: readU64,
-      input_tokens_after: readU64,
-      frozen_input_tokens: readU64,
-      output_shaped: readBool,
-      stages: readSequenceTypeStageReport
+      request_json: read_string,
+      provider: read_string,
+      model: read_Optionalstring,
+      tokenizer_label: read_string,
+      tokenizer_exact: read_bool,
+      input_tokens_before: read_u64,
+      input_tokens_after: read_u64,
+      frozen_input_tokens: read_u64,
+      output_shaped: read_bool,
+      stages: read_SequenceTypeStageReport
     )
   end
 
   # The Record type StageReport.
 
-  def readTypeStageReport
+  def read_TypeStageReport
     StageReport.new(
-      name: readString,
-      applied: readBool,
-      tokens_before: readU64,
-      tokens_after: readU64,
-      note: readOptionalstring
+      name: read_string,
+      applied: read_bool,
+      tokens_before: read_u64,
+      tokens_after: read_u64,
+      note: read_Optionalstring
     )
   end
 
@@ -348,17 +405,17 @@ class RustBufferStream
 
   # The Error type LlmtrimError
 
-  def readTypeLlmtrimError
+  def read_TypeLlmtrimError
     variant = unpack_from 4, 'l>'
     
     if variant == 1
         return LlmtrimError::Compress.new(
-            readString()
+            detail: read_string()
         )
     end
     if variant == 2
         return LlmtrimError::UnknownPreset.new(
-            readString()
+            name: read_string()
         )
     end
 
@@ -370,7 +427,7 @@ class RustBufferStream
   
   # The Enum type Provider.
 
-  def readTypeProvider
+  def read_TypeProvider
     variant = unpack_from 4, 'l>'
     
     if variant == 1
@@ -388,29 +445,31 @@ class RustBufferStream
 
   
 
+  
   # The Optional<T> type for string.
 
-  def readOptionalstring
+  def read_Optionalstring
     flag = unpack_from 1, 'c'
 
     if flag == 0
       return nil
     elsif flag == 1
-      return readString
+      return read_string
     else
       raise InternalError, 'Unexpected flag byte for Optionalstring'
     end
   end
 
+  
   # The Optional<T> type for TypeProvider.
 
-  def readOptionalTypeProvider
+  def read_OptionalTypeProvider
     flag = unpack_from 1, 'c'
 
     if flag == 0
       return nil
     elsif flag == 1
-      return readTypeProvider
+      return read_TypeProvider
     else
       raise InternalError, 'Unexpected flag byte for OptionalTypeProvider'
     end
@@ -418,7 +477,7 @@ class RustBufferStream
 
   # The Sequence<T> type for TypeStageReport.
 
-  def readSequenceTypeStageReport
+  def read_SequenceTypeStageReport
     count = unpack_from 4, 'l>'
 
     raise InternalError, 'Unexpected negative sequence length' if count.negative?
@@ -426,7 +485,7 @@ class RustBufferStream
     items = []
 
     count.times do
-      items.append readTypeStageReport
+      items.append read_TypeStageReport
     end
 
     items
@@ -478,17 +537,17 @@ class RustBufferBuilder
     end
   end
 
-  def write_U64(v)
-    v = LlmtrimFfi::uniffi_in_range(v, "u64", 0, 2**64)
+  def write_u64(v)
+    v = ::LlmtrimFfi::uniffi_in_range(v, "u64", 0, 2**64)
     pack_into(8, 'Q>', v)
   end
 
-  def write_Bool(v)
+  def write_bool(v)
     pack_into(1, 'c', v ? 1 : 0)
   end
 
-  def write_String(v)
-    v = LlmtrimFfi::uniffi_utf8(v)
+  def write_string(v)
+    v = ::LlmtrimFfi::uniffi_utf8(v)
     pack_into 4, 'l>', v.bytes.size
     write v
   end
@@ -496,36 +555,58 @@ class RustBufferBuilder
   # The Record type CompressOutput.
 
   def write_TypeCompressOutput(v)
-    self.write_String(v.request_json)
-    self.write_String(v.provider)
+    self.write_string(v.request_json)
+    self.write_string(v.provider)
     self.write_Optionalstring(v.model)
-    self.write_String(v.tokenizer_label)
-    self.write_Bool(v.tokenizer_exact)
-    self.write_U64(v.input_tokens_before)
-    self.write_U64(v.input_tokens_after)
-    self.write_U64(v.frozen_input_tokens)
-    self.write_Bool(v.output_shaped)
+    self.write_string(v.tokenizer_label)
+    self.write_bool(v.tokenizer_exact)
+    self.write_u64(v.input_tokens_before)
+    self.write_u64(v.input_tokens_after)
+    self.write_u64(v.frozen_input_tokens)
+    self.write_bool(v.output_shaped)
     self.write_SequenceTypeStageReport(v.stages)
   end
 
   # The Record type StageReport.
 
   def write_TypeStageReport(v)
-    self.write_String(v.name)
-    self.write_Bool(v.applied)
-    self.write_U64(v.tokens_before)
-    self.write_U64(v.tokens_after)
+    self.write_string(v.name)
+    self.write_bool(v.applied)
+    self.write_u64(v.tokens_before)
+    self.write_u64(v.tokens_after)
     self.write_Optionalstring(v.note)
   end
 
+  # The Error type LlmtrimError - write for callback error returns.
+
+  def write_TypeLlmtrimError(v)
+    if v.is_a?(LlmtrimError::Compress)
+      pack_into 4, 'l>', 1
+        self.write_string(v.detail)
+      return
+    end
+    if v.is_a?(LlmtrimError::UnknownPreset)
+      pack_into 4, 'l>', 2
+        self.write_string(v.name)
+      return
+    end
+  end
   
 
   # The Enum type Provider.
 
   def write_TypeProvider(v)
-    pack_into(4, 'l>', v)
+    if v == Provider::OPEN_AI
+      pack_into(4, 'l>', 1)
+    end
+    if v == Provider::ANTHROPIC
+      pack_into(4, 'l>', 2)
+    end
+    if v == Provider::GOOGLE
+      pack_into(4, 'l>', 3)
+    end
  end
-   
+  
 
   # The Optional<T> type for string.
 
@@ -534,7 +615,7 @@ class RustBufferBuilder
       pack_into(1, 'c', 0)
     else
       pack_into(1, 'c', 1)
-      self.write_String(v)
+      self.write_string(v)
     end
   end
 
@@ -608,29 +689,37 @@ CALL_PANIC = 2
 
 module LlmtrimError
   class Compress < StandardError
-    def initialize(detail)
+    def initialize(detail:)
+        
         @detail = detail
+        
         super()
-      end
+    end
+    
 
     attr_reader :detail
     
 
     def to_s
-     "#{self.class.name}(detail=#{@detail.inspect})"
+        "#{self.class.name}(detail=#{@detail.inspect})"
+
     end
   end
   class UnknownPreset < StandardError
-    def initialize(name)
+    def initialize(name:)
+        
         @name = name
+        
         super()
-      end
+    end
+    
 
     attr_reader :name
     
 
     def to_s
-     "#{self.class.name}(name=#{@name.inspect})"
+        "#{self.class.name}(name=#{@name.inspect})"
+
     end
   end
 
@@ -640,10 +729,7 @@ end
 
 # Map error modules to the RustBuffer method name that reads them
 ERROR_MODULE_TO_READER_METHOD = {
-
-  LlmtrimError => :readTypeLlmtrimError,
-
-
+LlmtrimError => :read_TypeLlmtrimError,
 }
 
 private_constant :ERROR_MODULE_TO_READER_METHOD, :CALL_SUCCESS, :CALL_ERROR, :CALL_PANIC,
@@ -651,7 +737,8 @@ private_constant :ERROR_MODULE_TO_READER_METHOD, :CALL_SUCCESS, :CALL_ERROR, :CA
 
 def self.consume_buffer_into_error(error_module, rust_buffer)
   rust_buffer.consumeWithStream do |stream|
-    reader_method = ERROR_MODULE_TO_READER_METHOD[error_module]
+    reader_method = ERROR_MODULE_TO_READER_METHOD[error_module] ||
+                    ERROR_MODULE_TO_READER_METHOD[error_module.name&.split('::')&.last]
     return stream.send(reader_method)
   end
 end
@@ -693,7 +780,7 @@ def self.rust_call_with_error(error_module, fn_name, *args)
     # with the message.  But if that code panics, then it just sends back
     # an empty buffer.
     if status.error_buf.len > 0
-      raise InternalError, status.error_buf.consumeIntoString()
+      raise InternalError, status.error_buf.consume_into_string
     else
       raise InternalError, "Rust panic"
     end
@@ -713,30 +800,386 @@ module UniFFILib
   ffi_lib File.expand_path('libllmtrim_ffi.so', __dir__)
   
 
+  # Define FFI callback types and structs (vtables, etc.)
+  
+  callback :RustFutureContinuationCallback,
+    [:uint64, :int8, ],
+    :void
+  
+  callback :ForeignFutureDroppedCallback,
+    [:uint64, ],
+    :void
+  
+  callback :CallbackInterfaceFree,
+    [:uint64, ],
+    :void
+  
+  callback :CallbackInterfaceClone,
+    [:uint64, ],
+    :uint64
+  
+  class ForeignFutureDroppedCallbackStruct < FFI::Struct
+    layout(
+      :handle, :uint64,
+      :free, :ForeignFutureDroppedCallback
+    )
+  end
+  
+  class ForeignFutureResultU8 < FFI::Struct
+    layout(
+      :return_value, :uint8,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteU8,
+    [:uint64, ForeignFutureResultU8.by_value, ],
+    :void
+  
+  class ForeignFutureResultI8 < FFI::Struct
+    layout(
+      :return_value, :int8,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteI8,
+    [:uint64, ForeignFutureResultI8.by_value, ],
+    :void
+  
+  class ForeignFutureResultU16 < FFI::Struct
+    layout(
+      :return_value, :uint16,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteU16,
+    [:uint64, ForeignFutureResultU16.by_value, ],
+    :void
+  
+  class ForeignFutureResultI16 < FFI::Struct
+    layout(
+      :return_value, :int16,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteI16,
+    [:uint64, ForeignFutureResultI16.by_value, ],
+    :void
+  
+  class ForeignFutureResultU32 < FFI::Struct
+    layout(
+      :return_value, :uint32,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteU32,
+    [:uint64, ForeignFutureResultU32.by_value, ],
+    :void
+  
+  class ForeignFutureResultI32 < FFI::Struct
+    layout(
+      :return_value, :int32,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteI32,
+    [:uint64, ForeignFutureResultI32.by_value, ],
+    :void
+  
+  class ForeignFutureResultU64 < FFI::Struct
+    layout(
+      :return_value, :uint64,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteU64,
+    [:uint64, ForeignFutureResultU64.by_value, ],
+    :void
+  
+  class ForeignFutureResultI64 < FFI::Struct
+    layout(
+      :return_value, :int64,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteI64,
+    [:uint64, ForeignFutureResultI64.by_value, ],
+    :void
+  
+  class ForeignFutureResultF32 < FFI::Struct
+    layout(
+      :return_value, :float,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteF32,
+    [:uint64, ForeignFutureResultF32.by_value, ],
+    :void
+  
+  class ForeignFutureResultF64 < FFI::Struct
+    layout(
+      :return_value, :double,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteF64,
+    [:uint64, ForeignFutureResultF64.by_value, ],
+    :void
+  
+  class ForeignFutureResultRustBuffer < FFI::Struct
+    layout(
+      :return_value, RustBuffer.by_value,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteRustBuffer,
+    [:uint64, ForeignFutureResultRustBuffer.by_value, ],
+    :void
+  
+  class ForeignFutureResultVoid < FFI::Struct
+    layout(
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteVoid,
+    [:uint64, ForeignFutureResultVoid.by_value, ],
+    :void
+  
   attach_function :uniffi_llmtrim_ffi_fn_func_compress,
     [RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustCallStatus.by_ref],
     RustBuffer.by_value
+  
   attach_function :ffi_llmtrim_ffi_rustbuffer_alloc,
     [:uint64, RustCallStatus.by_ref],
     RustBuffer.by_value
+  
   attach_function :ffi_llmtrim_ffi_rustbuffer_from_bytes,
     [ForeignBytes, RustCallStatus.by_ref],
     RustBuffer.by_value
+  
   attach_function :ffi_llmtrim_ffi_rustbuffer_free,
     [RustBuffer.by_value, RustCallStatus.by_ref],
     :void
+  
   attach_function :ffi_llmtrim_ffi_rustbuffer_reserve,
     [RustBuffer.by_value, :uint64, RustCallStatus.by_ref],
     RustBuffer.by_value
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_poll_u8,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_cancel_u8,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_free_u8,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_complete_u8,
+    [:uint64, RustCallStatus.by_ref],
+    :uint8
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_poll_i8,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_cancel_i8,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_free_i8,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_complete_i8,
+    [:uint64, RustCallStatus.by_ref],
+    :int8
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_poll_u16,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_cancel_u16,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_free_u16,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_complete_u16,
+    [:uint64, RustCallStatus.by_ref],
+    :uint16
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_poll_i16,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_cancel_i16,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_free_i16,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_complete_i16,
+    [:uint64, RustCallStatus.by_ref],
+    :int16
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_poll_u32,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_cancel_u32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_free_u32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_complete_u32,
+    [:uint64, RustCallStatus.by_ref],
+    :uint32
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_poll_i32,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_cancel_i32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_free_i32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_complete_i32,
+    [:uint64, RustCallStatus.by_ref],
+    :int32
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_poll_u64,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_cancel_u64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_free_u64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_complete_u64,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_poll_i64,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_cancel_i64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_free_i64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_complete_i64,
+    [:uint64, RustCallStatus.by_ref],
+    :int64
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_poll_f32,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_cancel_f32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_free_f32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_complete_f32,
+    [:uint64, RustCallStatus.by_ref],
+    :float
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_poll_f64,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_cancel_f64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_free_f64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_complete_f64,
+    [:uint64, RustCallStatus.by_ref],
+    :double
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_poll_rust_buffer,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_cancel_rust_buffer,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_free_rust_buffer,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_complete_rust_buffer,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_poll_void,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_cancel_void,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_free_void,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_llmtrim_ffi_rust_future_complete_void,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  
   attach_function :uniffi_llmtrim_ffi_checksum_func_compress,
-    [RustCallStatus.by_ref],
+    [],
     :uint16
+  
   attach_function :ffi_llmtrim_ffi_uniffi_contract_version,
-    [RustCallStatus.by_ref],
+    [],
     :uint32
   
 end
 
+  # Custom type definitions.
+
   # Public interface members begin here.
 
   
@@ -745,9 +1188,9 @@ end
   
 
 class Provider
-  OPEN_AI = 1
-  ANTHROPIC = 2
-  GOOGLE = 3
+  OPEN_AI = 0
+  ANTHROPIC = 1
+  GOOGLE = 2
   
 end
 
@@ -804,6 +1247,7 @@ class CompressOutput
 
     true
   end
+  
 end
   
   # Record type StageReport
@@ -837,6 +1281,7 @@ class StageReport
 
     true
   end
+  
 end
   
 
@@ -844,22 +1289,24 @@ end
   
 
 def self.compress(input, provider, preset)
-    input = LlmtrimFfi::uniffi_utf8(input)
+    input = ::LlmtrimFfi::uniffi_utf8(input)
     
     
     provider = (provider ? provider : nil)
     RustBuffer.check_lower_OptionalTypeProvider(provider)
     
-    preset = (preset ? LlmtrimFfi::uniffi_utf8(preset) : nil)
+    preset = (preset ? ::LlmtrimFfi::uniffi_utf8(preset) : nil)
     RustBuffer.check_lower_Optionalstring(preset)
     
-  result = LlmtrimFfi.rust_call_with_error(LlmtrimError,:uniffi_llmtrim_ffi_fn_func_compress,RustBuffer.allocFromString(input),RustBuffer.alloc_from_OptionalTypeProvider(provider),RustBuffer.alloc_from_Optionalstring(preset))
-  return result.consumeIntoTypeCompressOutput
+  result = ::LlmtrimFfi.rust_call_with_error(LlmtrimError,:uniffi_llmtrim_ffi_fn_func_compress,RustBuffer.alloc_from_string(input),RustBuffer.alloc_from_OptionalTypeProvider(provider),RustBuffer.alloc_from_Optionalstring(preset))
+  return result.consume_into_TypeCompressOutput
 end
 
 
   
 
   
+
+  
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: llmtrim
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: x86_64-linux
 authors:
 - François Kiene
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-29 00:00:00.000000000 Z
+date: 2026-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi