rllama 1.1.0-aarch64-linux-gnu → 1.2.0-aarch64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9381ace91f43a8d6aa654d0aca724935cdcf6e2813043c78a7e7ebbff9a3b59
-  data.tar.gz: 1aa70d6c8ab085692801587498a1c3bdf417c2d44ced52e8364588039b75534b
+  metadata.gz: 99e3ffe956c68e991661b218d27d0ed735efb0a36b6498d288d7dc4dd53fadef
+  data.tar.gz: 29cb1e766527527c2d53ad6f7d0dbbdb612c342b541cbb2a9b90c6becde859ad
 SHA512:
-  metadata.gz: 8a669a80b1a19d1425d1f7534833e7c5aee317128a333ef42d124f3ae5a72da512b9b59cd0f7cd011cfb9e53b4a0825044dc6e7aa9d05fbaea9ce778e4a30282
-  data.tar.gz: 82e1ab974b672585ad212207abc172cdc92756d21fe87fddf5e0cfdad97d77921b65671723d815481966be41811d1b14344dcafb1f677fca8c601f954ea6925f
+  metadata.gz: a76c30d46bd3cd39aff003fb5fcd097d13f03f0c507d23de4da0376fca057190258bf32f353e33610a3aaa2068145e97319bede5800788a197468714e2bfd44b
+  data.tar.gz: 469fc2dca9c5dac81ae290286af5ab4a07b0edf4e3488394cb3b8122218996a69528f44561226b871313ec1c430c72c4ab1a06135b27f472c65d6669f2e3ed72

data/LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2026 DocuSeal, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -24,12 +24,6 @@ Or install it yourself as:
 gem install rllama
 ```
 
-### Troubleshooting
-
-#### `llama_model_load_from_file_impl: no backends are loaded`
-
-If you're running on an Intel (x86_64) CPU and encounter this error while loading a model, make sure you're using the latest version of the gem. Rllama now preloads the bundled GGML backend libraries and automatically augments the `GGML_BACKEND_PATH`, so upgrading resolves the issue without any manual steps. If you build from source, ensure that directory is included in `GGML_BACKEND_PATH` before booting your Ruby process.
-
 ## CLI Chat
 
 The `rllama` command-line utility provides an interactive chat interface for conversing with language models. After installing the gem, you can start chatting immediately:
@@ -93,7 +87,14 @@ model.close
 
 #### Generation parameters
 
-Adjust the generation with parameters:
+By default the sampling parameters are taken from the model's own
+`general.sampling.*` GGUF metadata when present (falling back to llama.cpp's
+standard defaults: `temperature: 0.8`, `top_k: 40`, `top_p: 0.95`,
+`min_p: 0.05`). You can inspect the resolved values with
+`model.sampling_defaults`, or read any metadata key directly with
+`model.meta('general.sampling.temp')`.
+
+Pass any parameter explicitly to override the model default:
 
 ```ruby
 result = model.generate(
@@ -106,6 +107,9 @@ result = model.generate(
 )
 ```
 
+The parameters actually used are reported back in `result.stats`
+(`temperature`, `top_k`, `top_p`, `min_p`, `seed`).
+
 #### Streaming generation
 
 Stream generated text token-by-token:
@@ -141,6 +145,95 @@ result = model.generate([
 puts result.text
 ```
 
+#### Tool definitions
+
+Pass tool definitions to include them in the model's prompt for function calling:
+
+```ruby
+tools = [
+  {
+    type: 'function',
+    function: {
+      name: 'get_weather',
+      description: 'Get the current weather for a location',
+      parameters: {
+        type: 'object',
+        properties: {
+          location: { type: 'string', description: 'City name' }
+        },
+        required: ['location']
+      }
+    }
+  }
+]
+
+result = model.generate('What is the weather in Paris?', tools:)
+puts result.text
+```
+
+#### Tool call results
+
+Messages are passed to the model's chat template in the OpenAI format, so tool
+calls and their results are wired through the standard message schema: the
+assistant message carries a structured `tool_calls:` array, and the tool output
+is sent back as a `role: 'tool'` message.
+
+Pass `tools:` (and optionally `system:`) once when creating the context — they
+are remembered for all subsequent turns. When the model emits a tool call, it
+is parsed into `result.tool_calls` and stored in the conversation history in
+structured form automatically. Execute the calls and send each result back as
+a `role: 'tool'` message:
+
+```ruby
+context = model.init_context(tools:)
+
+result = context.generate('What is the weather in Paris?')
+result.tool_calls
+# => [{ name: 'get_weather', arguments: { 'location' => 'Paris' }, id: 'call_1' }]
+
+result.tool_calls.each do |call|
+  weather = get_weather(call[:arguments]['location'])
+
+  result = context.generate(
+    { role: 'tool', tool_call_id: call[:id], name: call[:name], content: weather.to_json }
+  )
+end
+
+puts result.text
+# => "The weather in Paris right now is 21°C."
+```
+
+The tool call markup is parsed by llama.cpp's chat parser, which derives the
+format automatically from the model's own chat template — any model with a
+tool-capable template is supported. If no tool call is detected,
+`result.tool_calls` is empty and `result.text` contains the raw output.
+
+The context detects the edited history and automatically rolls the KV cache
+back to the common prefix, so only the changed suffix is re-processed.
+
+### Reasoning
+
+For models with reasoning support, pass `reasoning: true` to
+enable the model's reasoning phase. The reasoning block is parsed out of the
+output: `result.text` contains only the final answer and the reasoning is
+available separately:
+
+```ruby
+result = model.generate('Why is the sky blue?', reasoning: true)
+
+result.reasoning
+# => "Thinking Process:\n\n1. Analyze the request..."
+
+result.text
+# => "The sky appears blue because..."
+```
+
+Like `tools:`, the flag can also be set once per context via
+`model.init_context(reasoning: true)`. It defaults to off; `result.reasoning`
+is `nil` when reasoning is disabled or the model produced no reasoning block.
+Note that when streaming with a block, the raw reasoning tokens are yielded
+as they are generated.
+
 ### Chat
 
 For ongoing conversations, use a context object that maintains the conversation history:
@@ -213,7 +306,6 @@ You can download GGUF format models from various sources:
 
 - [Hugging Face](https://huggingface.co/models?library=gguf) - Search for models with "GGUF" format
 
-
 ## License
 
 MIT

data/lib/rllama/aarch64-linux/libggml-base.so

@@ -0,0 +1 @@
+libggml-base.so.0

data/lib/rllama/aarch64-linux/libggml-base.so.0

@@ -0,0 +1 @@
+libggml-base.so.0.17.0

data/lib/rllama/aarch64-linux/libggml.so

@@ -0,0 +1 @@
+libggml.so.0

data/lib/rllama/aarch64-linux/libggml.so.0

@@ -0,0 +1 @@
+libggml.so.0.17.0

data/lib/rllama/aarch64-linux/libllama-common.so

@@ -0,0 +1 @@
+libllama-common.so.0

data/lib/rllama/aarch64-linux/libllama-common.so.0

@@ -0,0 +1 @@
+libllama-common.so.0.0.10067

data/lib/rllama/aarch64-linux/libllama.so

@@ -0,0 +1 @@
+libllama.so.0

data/lib/rllama/aarch64-linux/libllama.so.0

@@ -0,0 +1 @@
+libllama.so.0.0.10067

data/lib/rllama/common.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'json'
+
+module Rllama
+  module Common
+    extend FFI::Library
+
+    REASONING_FORMAT_AUTO = 1
+
+    lib_file =
+      case FFI::Platform::OS
+      when 'darwin'
+        'libllama_common.dylib'
+      when 'windows', 'mingw32'
+        'llama_common.dll'
+      else
+        'libllama_common.so'
+      end
+
+    ffi_lib File.join(Cpp::PLATFORM_DIR, lib_file)
+
+    attach_function :rlc_free, [:pointer], :void
+    attach_function :rlc_chat_templates_init, %i[pointer string string string pointer], :pointer
+    attach_function :rlc_chat_templates_free, [:pointer], :void
+    attach_function :rlc_chat_apply, %i[pointer string pointer], :pointer
+    attach_function :rlc_chat_parse, %i[string bool string pointer], :pointer
+    attach_function :rlc_sampler_init, %i[pointer string pointer], :pointer
+    attach_function :rlc_sampler_free, [:pointer], :void
+    attach_function :rlc_sampler_sample, %i[pointer pointer int32], :int32
+    attach_function :rlc_sampler_accept, %i[pointer int32 bool], :void
+    attach_function :rlc_sampler_reset, [:pointer], :void
+    attach_function :rlc_sampler_print, [:pointer], :pointer
+
+    module_function
+
+    def chat_templates_init(model, source, bos_token, eos_token)
+      with_err do |err|
+        handle = rlc_chat_templates_init(model, source, bos_token, eos_token, err)
+
+        raise Error, "Failed to parse chat template: #{read_err(err)}" if handle.null?
+
+        handle
+      end
+    end
+
+    def chat_templates_free(handle)
+      rlc_chat_templates_free(handle)
+    end
+
+    def chat_apply(handle, messages:, tools: nil, add_generation_prompt: true, enable_thinking: false,
+                   add_bos: false, add_eos: false)
+      inputs = { messages:, tools:, add_generation_prompt:, enable_thinking:, add_bos:, add_eos:,
+                 reasoning_format: enable_thinking ? REASONING_FORMAT_AUTO : 0 }.to_json
+
+      with_err do |err|
+        result = rlc_chat_apply(handle, inputs, err)
+
+        raise Error, "Failed to apply chat template: #{read_err(err)}" if result.null?
+
+        JSON.parse(take(result))
+      end
+    end
+
+    def chat_parse(text, params, is_partial: false, reasoning: false)
+      parse_params = params.slice('format', 'parser', 'generation_prompt')
+      parse_params['reasoning_format'] = REASONING_FORMAT_AUTO if reasoning
+      params_json = parse_params.to_json
+
+      with_err do |err|
+        result = rlc_chat_parse(text, is_partial, params_json, err)
+
+        raise Error, "Failed to parse output: #{read_err(err)}" if result.null?
+
+        JSON.parse(take(result))
+      end
+    end
+
+    def sampler_init(model, params)
+      with_err do |err|
+        handle = rlc_sampler_init(model, params.to_json, err)
+
+        raise Error, "Failed to initialize sampler: #{read_err(err)}" if handle.null?
+
+        handle
+      end
+    end
+
+    def sampler_free(handle)
+      rlc_sampler_free(handle)
+    end
+
+    def sampler_sample(handle, ctx, idx = -1)
+      rlc_sampler_sample(handle, ctx, idx)
+    end
+
+    def sampler_accept(handle, token, accept_grammar: true)
+      rlc_sampler_accept(handle, token, accept_grammar)
+    end
+
+    def sampler_reset(handle)
+      rlc_sampler_reset(handle)
+    end
+
+    def sampler_print(handle)
+      take(rlc_sampler_print(handle))
+    end
+
+    def with_err
+      yield FFI::MemoryPointer.new(:pointer)
+    end
+
+    def take(ptr)
+      str = ptr.read_string
+
+      rlc_free(ptr)
+
+      str
+    end
+
+    def read_err(err)
+      msg_ptr = err.read_pointer
+
+      return 'unknown error' if msg_ptr.null?
+
+      msg = msg_ptr.read_string
+
+      rlc_free(msg_ptr)
+
+      msg
+    end
+  end
+end