llmtrim 0.1.8-x86_64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 237c79248620a23758b8905ce7d120e47c01c0bc836c2b3b4fdee3f69d3be730
+  data.tar.gz: 2718650291447a33d958eb0f873217f32c4483d4337fafbcf9909729133e226e
+SHA512:
+  metadata.gz: 8d408f6326aa2ce3c19c7c08e495710ab6c530bf3566e58f28b834d5552d74dc9fd0e1bc53cf4f82f3d7ce7750ae4a50516afccf0e62fa78c95307befa826ce1
+  data.tar.gz: 00aca640ee50fe5774ebe00ac8f2101a11647202a13c42148c456087325b9947f22eeb70b8dfea921e31a3894fb242d59431746dfcb81b6fc3e4b03660d3fc1a

data/README.md

@@ -0,0 +1,24 @@
+# llmtrim (Ruby)
+
+Native, in-process bindings to the [llmtrim](https://github.com/fkiene/llmtrim)
+compression engine — cut 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,733 @@
+# 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)
+    
+    
+    
+    
+    
+    
+  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 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
+
+  
+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
+    )
+  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
+
+  
+
+  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)
+  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
+
+  
+
+  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.so', __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
+
+  def initialize(request_json:, provider:, model:, tokenizer_label:, tokenizer_exact:, input_tokens_before:, input_tokens_after:, frozen_input_tokens:, output_shaped:)
+    @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
+  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
+
+    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,63 @@
+--- !ruby/object:Gem::Specification
+name: llmtrim
+version: !ruby/object:Gem::Version
+  version: 0.1.8
+platform: x86_64-linux
+authors:
+- François Kiene
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-06-13 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.so
+- 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 — cut input tokens 30-90%.
+test_files: []