llmtrim 0.1.10-arm64-darwin

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 371a1841e32aa99efe6b330d55e589357e2a9349413a3bdefa6f6239eae59592
+  data.tar.gz: 2a941fa33b123f62b2574cafa81f219f6cada9221a9111dbb1db3e7f4f24f8a1
+SHA512:
+  metadata.gz: aaf480cc6694d87d992290a9f087f9f96c317983896a219f248a5c55cc6180f48c7c04f39a0bbbdffcac0ded343d7a492ad5ae02b7fa4d6c44eaf1cd189fb6c4
+  data.tar.gz: 3ba67355d060d10e136230c03c526ba58a4d03f87eec36433f80e5257994c121320a81a96d547f184d4fb2643142ad369455a71a6912b150a38fe760cc1b075a

data/README.md

@@ -0,0 +1,24 @@
+# llmtrim (Ruby)
+
+Native, in-process bindings to the [llmtrim](https://github.com/fkiene/llmtrim)
+compression engine, cutting LLM input tokens 30–90% with zero extra model calls, no network,
+no server. The compiled engine is bundled in the gem, so no Rust toolchain is needed.
+
+```ruby
+require "llmtrim"
+require "json"
+
+req = JSON.generate("model" => "gpt-4o",
+                    "messages" => [{ "role" => "user", "content" => "…" }])
+out = Llmtrim.compress(req, Llmtrim::Provider::OPEN_AI, "aggressive")
+puts "#{out.input_tokens_before} -> #{out.input_tokens_after}"
+# send out.request_json to the provider
+```
+
+`compress(input, provider, preset)`: `provider` is `Llmtrim::Provider::OPEN_AI` /
+`ANTHROPIC` / `GOOGLE` or `nil` to auto-detect; `preset` is a workload name
+(`"aggressive"`, `"agent"`, `"code"`, `"rag"`, `"safe"`, …) or `nil` for the environment
+config. Raises `Llmtrim::LlmtrimError::Compress` / `UnknownPreset` on error.
+
+Built with `crates/llmtrim-uniffi/scripts/build-gem.sh` (platform-specific gem with the
+bundled native library). License: AGPL-3.0-only.

data/lib/llmtrim/llmtrim_ffi.rb

@@ -0,0 +1,865 @@
+# This file was autogenerated by some hot garbage in the `uniffi` crate.
+# Trust me, you don't want to mess with it!
+
+# Common helper code.
+#
+# Ideally this would live in a separate .rb file where it can be unittested etc
+# in isolation, and perhaps even published as a re-useable package.
+#
+# However, it's important that the details of how this helper code works (e.g. the
+# way that different builtin types are passed across the FFI) exactly match what's
+# expected by the rust code on the other side of the interface. In practice right
+# now that means coming from the exact some version of `uniffi` that was used to
+# compile the rust component. The easiest way to ensure this is to bundle the Ruby
+# helpers directly inline like we're doing here.
+
+require 'ffi'
+
+
+module LlmtrimFfi
+  def self.uniffi_in_range(i, type_name, min, max)
+  raise TypeError, "no implicit conversion of #{i} into Integer" unless i.respond_to?(:to_int)
+  i = i.to_int
+  raise RangeError, "#{type_name} requires #{min} <= value < #{max}" unless (min <= i && i < max)
+  i
+end
+
+def self.uniffi_utf8(v)
+  raise TypeError, "no implicit conversion of #{v} into String" unless v.respond_to?(:to_str)
+  v = v.to_str.encode(Encoding::UTF_8)
+  raise Encoding::InvalidByteSequenceError, "not a valid UTF-8 encoded string" unless v.valid_encoding?
+  v
+end
+
+def self.uniffi_bytes(v)
+  raise TypeError, "no implicit conversion of #{v} into String" unless v.respond_to?(:to_str)
+  v.to_str
+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)
+  end
+
+  def self.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)
+  end
+
+  def capacity
+    self[:capacity]
+  end
+
+  def len
+    self[:len]
+  end
+
+  def len=(value)
+    self[:len] = value
+  end
+
+  def data
+    self[:data]
+  end
+
+  def to_s
+    "RustBuffer(capacity=#{capacity}, len=#{len}, data=#{data.read_bytes len})"
+  end
+
+  # The allocated buffer will be automatically freed if an error occurs, ensuring that
+  # we don't accidentally leak it.
+  def self.allocWithBuilder
+    builder = RustBufferBuilder.new
+
+    begin
+      yield builder
+    rescue => e
+      builder.discard
+      raise e
+    end
+  end
+
+  # The RustBuffer will be freed once the context-manager exits, ensuring that we don't
+  # leak it even if an error occurs.
+  def consumeWithStream
+    stream = RustBufferStream.new self
+
+    yield stream
+
+    raise RuntimeError, 'junk data left in buffer after consuming' if stream.remaining != 0
+  ensure
+    free
+  end# The primitive String type.
+
+  def self.allocFromString(value)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write value.encode('utf-8')
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoString
+    consumeWithStream do |stream|
+      return stream.read(stream.remaining).force_encoding(Encoding::UTF_8)
+    end
+  end
+
+  # The Record type CompressOutput.
+
+  def self.check_lower_TypeCompressOutput(v)
+    
+    
+    RustBuffer.check_lower_Optionalstring(v.model)
+    
+    
+    
+    
+    
+    
+    RustBuffer.check_lower_SequenceTypeStageReport(v.stages)
+  end
+
+  def self.alloc_from_TypeCompressOutput(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeCompressOutput(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeCompressOutput
+    consumeWithStream do |stream|
+      return stream.readTypeCompressOutput
+    end
+  end
+
+  # The Record type StageReport.
+
+  def self.check_lower_TypeStageReport(v)
+    
+    
+    
+    
+    RustBuffer.check_lower_Optionalstring(v.note)
+  end
+
+  def self.alloc_from_TypeStageReport(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeStageReport(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeStageReport
+    consumeWithStream do |stream|
+      return stream.readTypeStageReport
+    end
+  end
+
+  
+
+  # The Enum type Provider.
+
+  def self.check_lower_TypeProvider(v)
+  end
+
+  def self.alloc_from_TypeProvider(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeProvider(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeProvider
+    consumeWithStream do |stream|
+      return stream.readTypeProvider
+    end
+  end
+  
+
+  # The Optional<T> type for string.
+
+  def self.check_lower_Optionalstring(v)
+    if not v.nil?
+      
+    end
+  end
+
+  def self.alloc_from_Optionalstring(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Optionalstring(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalstring
+    consumeWithStream do |stream|
+      return stream.readOptionalstring
+    end
+  end
+
+  # The Optional<T> type for TypeProvider.
+
+  def self.check_lower_OptionalTypeProvider(v)
+    if not v.nil?
+      RustBuffer.check_lower_TypeProvider(v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypeProvider(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeProvider(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalTypeProvider
+    consumeWithStream do |stream|
+      return stream.readOptionalTypeProvider
+    end
+  end
+
+  # The Sequence<T> type for TypeStageReport.
+
+  def self.check_lower_SequenceTypeStageReport(v)
+    v.each do |item|
+      RustBuffer.check_lower_TypeStageReport(item)
+    end
+  end
+
+  def self.alloc_from_SequenceTypeStageReport(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_SequenceTypeStageReport(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoSequenceTypeStageReport
+    consumeWithStream do |stream|
+      return stream.readSequenceTypeStageReport
+    end
+  end
+
+  
+end
+
+module UniFFILib
+  class ForeignBytes < FFI::Struct
+    layout :len,      :int32,
+           :data,     :pointer
+
+    def len
+      self[:len]
+    end
+
+    def data
+      self[:data]
+    end
+
+    def to_s
+      "ForeignBytes(len=#{len}, data=#{data.read_bytes(len)})"
+    end
+  end
+end
+
+private_constant :UniFFILib
+  
+# Helper for structured reading of values from a RustBuffer.
+class RustBufferStream
+
+  def initialize(rbuf)
+    @rbuf = rbuf
+    @offset = 0
+  end
+
+  def remaining
+    @rbuf.len - @offset
+  end
+
+  def read(size)
+    raise InternalError, 'read past end of rust buffer' if @offset + size > @rbuf.len
+
+    data = @rbuf.data.get_bytes @offset, size
+
+    @offset += size
+
+    data
+  end
+
+  def readU64
+    unpack_from 8, 'Q>'
+  end
+
+  def readBool
+    v = unpack_from 1, 'c'
+
+    return false if v == 0
+    return true if v == 1
+
+    raise InternalError, 'Unexpected byte for Boolean type'
+  end
+
+  def readString
+    size = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative string length' if size.negative?
+
+    read(size).force_encoding(Encoding::UTF_8)
+  end
+
+  # The Record type CompressOutput.
+
+  def readTypeCompressOutput
+    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
+    )
+  end
+
+  # The Record type StageReport.
+
+  def readTypeStageReport
+    StageReport.new(
+      name: readString,
+      applied: readBool,
+      tokens_before: readU64,
+      tokens_after: readU64,
+      note: readOptionalstring
+    )
+  end
+
+  
+
+  
+
+  # The Error type LlmtrimError
+
+  def readTypeLlmtrimError
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+        return LlmtrimError::Compress.new(
+            readString()
+        )
+    end
+    if variant == 2
+        return LlmtrimError::UnknownPreset.new(
+            readString()
+        )
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeLlmtrimError'
+  end
+  
+
+  
+  
+  # The Enum type Provider.
+
+  def readTypeProvider
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+      return Provider::OPEN_AI
+    end
+    if variant == 2
+      return Provider::ANTHROPIC
+    end
+    if variant == 3
+      return Provider::GOOGLE
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeProvider'
+  end
+
+  
+
+  # The Optional<T> type for string.
+
+  def readOptionalstring
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readString
+    else
+      raise InternalError, 'Unexpected flag byte for Optionalstring'
+    end
+  end
+
+  # The Optional<T> type for TypeProvider.
+
+  def readOptionalTypeProvider
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readTypeProvider
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeProvider'
+    end
+  end
+
+  # The Sequence<T> type for TypeStageReport.
+
+  def readSequenceTypeStageReport
+    count = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative sequence length' if count.negative?
+
+    items = []
+
+    count.times do
+      items.append readTypeStageReport
+    end
+
+    items
+  end
+
+  
+
+  def unpack_from(size, format)
+    raise InternalError, 'read past end of rust buffer' if @offset + size > @rbuf.len
+
+    value = @rbuf.data.get_bytes(@offset, size).unpack format
+
+    @offset += size
+
+    # TODO: verify this
+    raise 'more than one element!!!' if value.size > 1
+
+    value[0]
+  end
+end
+
+private_constant :RustBufferStream
+  
+# Helper for structured writing of values into a RustBuffer.
+class RustBufferBuilder
+  def initialize
+    @rust_buf = RustBuffer.alloc 16
+    @rust_buf.len = 0
+  end
+
+  def finalize
+    rbuf = @rust_buf
+
+    @rust_buf = nil
+
+    rbuf
+  end
+
+  def discard
+    return if @rust_buf.nil?
+
+    rbuf = finalize
+    rbuf.free
+  end
+
+  def write(value)
+    reserve(value.bytes.size) do
+      @rust_buf.data.put_array_of_char @rust_buf.len, value.bytes
+    end
+  end
+
+  def write_U64(v)
+    v = LlmtrimFfi::uniffi_in_range(v, "u64", 0, 2**64)
+    pack_into(8, 'Q>', v)
+  end
+
+  def write_Bool(v)
+    pack_into(1, 'c', v ? 1 : 0)
+  end
+
+  def write_String(v)
+    v = LlmtrimFfi::uniffi_utf8(v)
+    pack_into 4, 'l>', v.bytes.size
+    write v
+  end
+
+  # The Record type CompressOutput.
+
+  def write_TypeCompressOutput(v)
+    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_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_Optionalstring(v.note)
+  end
+
+  
+
+  # The Enum type Provider.
+
+  def write_TypeProvider(v)
+    pack_into(4, 'l>', v)
+ end
+   
+
+  # The Optional<T> type for string.
+
+  def write_Optionalstring(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_String(v)
+    end
+  end
+
+  # The Optional<T> type for TypeProvider.
+
+  def write_OptionalTypeProvider(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeProvider(v)
+    end
+  end
+
+  # The Sequence<T> type for TypeStageReport.
+
+  def write_SequenceTypeStageReport(items)
+    pack_into(4, 'l>', items.size)
+
+    items.each do |item|
+      self.write_TypeStageReport(item)
+    end
+  end
+
+  
+
+  private
+
+  def reserve(num_bytes)
+    if @rust_buf.len + num_bytes > @rust_buf.capacity
+      @rust_buf = RustBuffer.reserve(@rust_buf, num_bytes)
+    end
+
+    yield
+
+    @rust_buf.len += num_bytes
+  end
+
+  def pack_into(size, format, value)
+    reserve(size) do
+      @rust_buf.data.put_array_of_char @rust_buf.len, [value].pack(format).bytes
+    end
+  end
+end
+
+private_constant :RustBufferBuilder
+
+  # Error definitions
+  class RustCallStatus < FFI::Struct
+  layout :code,    :int8,
+         :error_buf, RustBuffer
+
+  def code
+    self[:code]
+  end
+
+  def error_buf
+    self[:error_buf]
+  end
+
+  def to_s
+    "RustCallStatus(code=#{self[:code]})"
+  end
+end
+
+# These match the values from the uniffi::rustcalls module
+CALL_SUCCESS = 0
+CALL_ERROR = 1
+CALL_PANIC = 2
+
+
+module LlmtrimError
+  class Compress < StandardError
+    def initialize(detail)
+        @detail = detail
+        super()
+      end
+
+    attr_reader :detail
+    
+
+    def to_s
+     "#{self.class.name}(detail=#{@detail.inspect})"
+    end
+  end
+  class UnknownPreset < StandardError
+    def initialize(name)
+        @name = name
+        super()
+      end
+
+    attr_reader :name
+    
+
+    def to_s
+     "#{self.class.name}(name=#{@name.inspect})"
+    end
+  end
+
+end
+
+
+
+# Map error modules to the RustBuffer method name that reads them
+ERROR_MODULE_TO_READER_METHOD = {
+
+  LlmtrimError => :readTypeLlmtrimError,
+
+
+}
+
+private_constant :ERROR_MODULE_TO_READER_METHOD, :CALL_SUCCESS, :CALL_ERROR, :CALL_PANIC,
+                 :RustCallStatus
+
+def self.consume_buffer_into_error(error_module, rust_buffer)
+  rust_buffer.consumeWithStream do |stream|
+    reader_method = ERROR_MODULE_TO_READER_METHOD[error_module]
+    return stream.send(reader_method)
+  end
+end
+
+class InternalError < StandardError
+end
+
+def self.rust_call(fn_name, *args)
+  # Call a rust function
+  rust_call_with_error(nil, fn_name, *args)
+end
+
+def self.rust_call_with_error(error_module, fn_name, *args)
+  # Call a rust function and handle errors
+  #
+  # Use this when the rust function returns a Result<>.  error_module must be the error_module that corresponds to that Result.
+
+
+  # Note: RustCallStatus.new zeroes out the struct, which is exactly what we
+  # want to pass to Rust (code=0, error_buf=RustBuffer(len=0, capacity=0,
+  # data=NULL))
+  status = RustCallStatus.new
+  args << status
+
+  result = UniFFILib.public_send(fn_name, *args)
+
+  case status.code
+  when CALL_SUCCESS
+    result
+  when CALL_ERROR
+    if error_module.nil?
+      status.error_buf.free
+      raise InternalError, "CALL_ERROR with no error_module set"
+    else
+      raise consume_buffer_into_error(error_module, status.error_buf)
+    end
+  when CALL_PANIC
+    # When the rust code sees a panic, it tries to construct a RustBuffer
+    # 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()
+    else
+      raise InternalError, "Rust panic"
+    end
+  else
+    raise InternalError, "Unknown call status: #{status.code}"
+  end
+end
+
+private_class_method :consume_buffer_into_error
+
+  # This is how we find and load the dynamic library provided by the component.
+# For now we just look it up by name.
+module UniFFILib
+  extend FFI::Library
+
+  
+  ffi_lib File.expand_path('libllmtrim_ffi.dylib', __dir__)
+  
+
+  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 :uniffi_llmtrim_ffi_checksum_func_compress,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :ffi_llmtrim_ffi_uniffi_contract_version,
+    [RustCallStatus.by_ref],
+    :uint32
+  
+end
+
+  # Public interface members begin here.
+
+  
+  
+  
+  
+
+class Provider
+  OPEN_AI = 1
+  ANTHROPIC = 2
+  GOOGLE = 3
+  
+end
+
+
+  
+  # Record type CompressOutput
+class CompressOutput
+  attr_reader :request_json, :provider, :model, :tokenizer_label, :tokenizer_exact, :input_tokens_before, :input_tokens_after, :frozen_input_tokens, :output_shaped, :stages
+
+  def initialize(request_json:, provider:, model:, tokenizer_label:, tokenizer_exact:, input_tokens_before:, input_tokens_after:, frozen_input_tokens:, output_shaped:, stages:)
+    @request_json = request_json
+    @provider = provider
+    @model = model
+    @tokenizer_label = tokenizer_label
+    @tokenizer_exact = tokenizer_exact
+    @input_tokens_before = input_tokens_before
+    @input_tokens_after = input_tokens_after
+    @frozen_input_tokens = frozen_input_tokens
+    @output_shaped = output_shaped
+    @stages = stages
+  end
+
+  def ==(other)
+    if @request_json != other.request_json
+      return false
+    end
+    if @provider != other.provider
+      return false
+    end
+    if @model != other.model
+      return false
+    end
+    if @tokenizer_label != other.tokenizer_label
+      return false
+    end
+    if @tokenizer_exact != other.tokenizer_exact
+      return false
+    end
+    if @input_tokens_before != other.input_tokens_before
+      return false
+    end
+    if @input_tokens_after != other.input_tokens_after
+      return false
+    end
+    if @frozen_input_tokens != other.frozen_input_tokens
+      return false
+    end
+    if @output_shaped != other.output_shaped
+      return false
+    end
+    if @stages != other.stages
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type StageReport
+class StageReport
+  attr_reader :name, :applied, :tokens_before, :tokens_after, :note
+
+  def initialize(name:, applied:, tokens_before:, tokens_after:, note:)
+    @name = name
+    @applied = applied
+    @tokens_before = tokens_before
+    @tokens_after = tokens_after
+    @note = note
+  end
+
+  def ==(other)
+    if @name != other.name
+      return false
+    end
+    if @applied != other.applied
+      return false
+    end
+    if @tokens_before != other.tokens_before
+      return false
+    end
+    if @tokens_after != other.tokens_after
+      return false
+    end
+    if @note != other.note
+      return false
+    end
+
+    true
+  end
+end
+  
+
+  
+  
+
+def self.compress(input, provider, preset)
+    input = LlmtrimFfi::uniffi_utf8(input)
+    
+    
+    provider = (provider ? provider : nil)
+    RustBuffer.check_lower_OptionalTypeProvider(provider)
+    
+    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
+end
+
+
+  
+
+  
+end
+

data/lib/llmtrim.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# llmtrim — static, deterministic LLM prompt/payload compression.
+#
+# Thin entry point: load the UniFFI-generated bindings (which the build step patched to
+# load the native library bundled inside this gem) and re-expose them under `Llmtrim`.
+#
+#   require "llmtrim"
+#   out = Llmtrim.compress(request_json, Llmtrim::Provider::OPEN_AI, "aggressive")
+#   out.input_tokens_before # => Integer
+#
+# The compression runs natively in-process via the bundled `llmtrim-core` engine.
+
+require_relative "llmtrim/llmtrim_ffi"
+
+# `LlmtrimFfi` is the module name UniFFI derives from the crate; alias it to the friendlier
+# `Llmtrim` without breaking the generated internals.
+Llmtrim = LlmtrimFfi

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: llmtrim
+version: !ruby/object:Gem::Version
+  version: 0.1.10
+platform: arm64-darwin
+authors:
+- François Kiene
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-06-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+description: Native in-process bindings to the llmtrim-core compression engine (no
+  network, no extra model calls), generated via UniFFI.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/llmtrim.rb
+- lib/llmtrim/libllmtrim_ffi.dylib
+- lib/llmtrim/llmtrim_ffi.rb
+homepage: https://github.com/fkiene/llmtrim
+licenses:
+- AGPL-3.0-only
+metadata:
+  source_code_uri: https://github.com/fkiene/llmtrim
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Static, deterministic LLM prompt/payload compression that cuts input tokens
+  30-90%.
+test_files: []