lex-ollama 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c524d3518516ca7731280a6e84a2b354b12b47b516545a23bec97f6eda373a90
-  data.tar.gz: fbfcff5614ac931e74219661eb792f295dfb65d125c93ddb190b40eae74c6f81
+  metadata.gz: 7f82aeecea946b03e08e2dc80a8ec66504276a2bb28aaaca5528d02105328166
+  data.tar.gz: 6b7b392634ec069693a0b0b030b1619a0a5ae1d3cbb34c2440124c1c52d15e4a
 SHA512:
-  metadata.gz: 8975e31624faf65d869fcbe9c512fbf9d35b468bae3b5267726126312ccbe4520f8c5ff339550ce1d2ea44b2561c90d383ae847c67d826e538dd04a2f8a5c2ff
-  data.tar.gz: 4a01f66393c2a78bbd9cccb707ed19156338501f1de46e2afa78508b4be7d93354e90a01a7eef0acc14c18b817d39189d5fc50152da7905ce311d9d537bf0bfe
+  metadata.gz: 25b18ed44dbad71930004a3384dc897e37b245d3cdafa98122e0210a22ac5d5e6be343ab0133e519f8228f026d254e4993ee597f13368590c2fa81971329c6a8
+  data.tar.gz: 39b9f4ed1e8a7ccd447b03770a9757c7e2cdbcea03341f07c2dda561db72e3556029152c76256e6f8b85b6d0cb858773e2d7ee9989d5559ffdc9daccfcf6b966

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.2.0] - 2026-03-31
+
+### Added
+- `Helpers::Errors` — Faraday exception classification (TimeoutError, ConnectionFailed) with exponential backoff retry (`with_retry`, 3 retries, 0.5s base delay)
+- `Helpers::Usage` — standardized usage hash normalization from Ollama response fields (`prompt_eval_count` -> `input_tokens`, `eval_count` -> `output_tokens`, plus duration fields)
+- `Helpers::Client#streaming_client` — Faraday connection without JSON response middleware for streaming endpoints
+- `Runners::Completions#generate_stream` — streaming generate with per-chunk block callback and full text accumulation
+- `Runners::Chat#chat_stream` — streaming chat with per-chunk block callback and full text accumulation
+
+### Changed
+- All runner methods wrapped in `Helpers::Errors.with_retry` for production reliability
+- `Runners::Completions#generate` now returns a `usage:` key with standardized token/duration counts
+- `Runners::Chat#chat` now returns a `usage:` key with standardized token/duration counts
+- `Client` class now overrides `streaming_client` for host passthrough
+
 ## [0.1.0] - 2026-03-31
 
 ### Added

data/README.md

@@ -12,9 +12,11 @@ gem install lex-ollama
 
 ### Completions
 - `generate` - Generate a text completion (POST /api/generate)
+- `generate_stream` - Stream a text completion with per-chunk callbacks
 
 ### Chat
 - `chat` - Generate a chat completion with message history and tool support (POST /api/chat)
+- `chat_stream` - Stream a chat completion with per-chunk callbacks
 
 ### Models
 - `create_model` - Create a model from another model, GGUF, or safetensors (POST /api/create)
@@ -54,6 +56,27 @@ result = client.embed(model: 'all-minilm', input: 'Some text to embed')
 
 # List models
 result = client.list_models
+
+# Streaming generate
+client.generate_stream(model: 'llama3.2', prompt: 'Tell me a story') do |event|
+  case event[:type]
+  when :delta then print event[:text]
+  when :done  then puts "\nDone!"
+  end
+end
+
+# Streaming chat
+client.chat_stream(model: 'llama3.2', messages: [{ role: 'user', content: 'Hello!' }]) do |event|
+  print event[:text] if event[:type] == :delta
+end
+```
+
+All API calls include automatic retry with exponential backoff on connection failures and timeouts.
+
+Generate and chat responses include standardized `usage:` data:
+```ruby
+result = client.generate(model: 'llama3.2', prompt: 'Hello')
+result[:usage]  # => { input_tokens: 1, output_tokens: 5, total_duration: ..., ... }
 ```
 
 ## Requirements

data/lib/legion/extensions/ollama/client.rb

@@ -29,6 +29,10 @@ module Legion
         def client(**override)
           super(**@opts, **override)
         end
+
+        def streaming_client(**override)
+          super(**@opts, **override)
+        end
       end
     end
   end

data/lib/legion/extensions/ollama/helpers/client.rb

@@ -18,6 +18,15 @@ module Legion
               conn.options.open_timeout = 10
             end
           end
+
+          def streaming_client(host: DEFAULT_HOST, **)
+            Faraday.new(url: host) do |conn|
+              conn.request :json
+              conn.headers['Content-Type'] = 'application/json'
+              conn.options.timeout = 300
+              conn.options.open_timeout = 10
+            end
+          end
         end
       end
     end

data/lib/legion/extensions/ollama/helpers/errors.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Ollama
+      module Helpers
+        module Errors
+          MAX_RETRIES = 3
+          BASE_DELAY = 0.5
+          MAX_DELAY = 16
+
+          RETRYABLE_EXCEPTIONS = [
+            Faraday::TimeoutError,
+            Faraday::ConnectionFailed
+          ].freeze
+
+          module_function
+
+          def retryable?(exception)
+            RETRYABLE_EXCEPTIONS.any? { |klass| exception.is_a?(klass) }
+          end
+
+          def with_retry(max_retries: MAX_RETRIES)
+            retries = 0
+            begin
+              yield
+            rescue *RETRYABLE_EXCEPTIONS
+              retries += 1
+              raise if retries > max_retries
+
+              delay = [BASE_DELAY * (2**(retries - 1)), MAX_DELAY].min
+              sleep(delay)
+              retry
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/ollama/helpers/usage.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Ollama
+      module Helpers
+        module Usage
+          EMPTY_USAGE = {
+            input_tokens:         0,
+            output_tokens:        0,
+            total_duration:       0,
+            load_duration:        0,
+            prompt_eval_duration: 0,
+            eval_duration:        0
+          }.freeze
+
+          module_function
+
+          def from_response(body)
+            return EMPTY_USAGE.dup unless body.is_a?(Hash)
+
+            {
+              input_tokens:         body['prompt_eval_count'] || 0,
+              output_tokens:        body['eval_count'] || 0,
+              total_duration:       body['total_duration'] || 0,
+              load_duration:        body['load_duration'] || 0,
+              prompt_eval_duration: body['prompt_eval_duration'] || 0,
+              eval_duration:        body['eval_duration'] || 0
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/ollama/runners/blobs.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/ollama/helpers/client'
+require 'legion/extensions/ollama/helpers/errors'
 
 module Legion
   module Extensions
@@ -10,14 +11,16 @@ module Legion
           extend Legion::Extensions::Ollama::Helpers::Client
 
           def check_blob(digest:, **)
-            response = client(**).head("/api/blobs/#{digest}")
+            response = Helpers::Errors.with_retry { client(**).head("/api/blobs/#{digest}") }
             { result: response.status == 200, status: response.status }
           end
 
           def push_blob(digest:, body:, **)
-            response = client(**).post("/api/blobs/#{digest}") do |req|
-              req.headers['Content-Type'] = 'application/octet-stream'
-              req.body = body
+            response = Helpers::Errors.with_retry do
+              client(**).post("/api/blobs/#{digest}") do |req|
+                req.headers['Content-Type'] = 'application/octet-stream'
+                req.body = body
+              end
             end
             { result: response.status == 201, status: response.status }
           end

data/lib/legion/extensions/ollama/runners/chat.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
+require 'json'
 require 'legion/extensions/ollama/helpers/client'
+require 'legion/extensions/ollama/helpers/errors'
+require 'legion/extensions/ollama/helpers/usage'
 
 module Legion
   module Extensions
@@ -12,8 +15,40 @@ module Legion
           def chat(model:, messages:, tools: nil, format: nil, options: nil, stream: false, keep_alive: nil, think: nil, **)
             body = { model: model, messages: messages, tools: tools, format: format, options: options,
                      stream: stream, keep_alive: keep_alive, think: think }.compact
-            response = client(**).post('/api/chat', body)
-            { result: response.body, status: response.status }
+            response = Helpers::Errors.with_retry { client(**).post('/api/chat', body) }
+            { result: response.body, usage: Helpers::Usage.from_response(response.body), status: response.status }
+          end
+
+          def chat_stream(model:, messages:, tools: nil, format: nil, options: nil, keep_alive: nil, think: nil, **, &block)
+            body = { model: model, messages: messages, tools: tools, format: format, options: options,
+                     stream: true, keep_alive: keep_alive, think: think }.compact
+            accumulated = +''
+            final_response = nil
+            buffer = +''
+
+            Helpers::Errors.with_retry do
+              streaming_client(**).post('/api/chat', body) do |req|
+                req.options.on_data = proc do |chunk, _size|
+                  buffer << chunk
+                  while (idx = buffer.index("\n"))
+                    line = buffer.slice!(0, idx + 1).strip
+                    next if line.empty?
+
+                    parsed = ::JSON.parse(line)
+                    if parsed['done']
+                      final_response = parsed
+                      block&.call({ type: :done, data: parsed })
+                    else
+                      text = parsed.dig('message', 'content') || ''
+                      accumulated << text
+                      block&.call({ type: :delta, text: text })
+                    end
+                  end
+                end
+              end
+            end
+
+            { result: accumulated, usage: Helpers::Usage.from_response(final_response), status: 200 }
           end
 
           include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&

data/lib/legion/extensions/ollama/runners/completions.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
+require 'json'
 require 'legion/extensions/ollama/helpers/client'
+require 'legion/extensions/ollama/helpers/errors'
+require 'legion/extensions/ollama/helpers/usage'
 
 module Legion
   module Extensions
@@ -12,8 +15,40 @@ module Legion
           def generate(model:, prompt: nil, images: nil, format: nil, options: nil, system: nil, stream: false, keep_alive: nil, **)
             body = { model: model, prompt: prompt, images: images, format: format, options: options,
                      system: system, stream: stream, keep_alive: keep_alive }.compact
-            response = client(**).post('/api/generate', body)
-            { result: response.body, status: response.status }
+            response = Helpers::Errors.with_retry { client(**).post('/api/generate', body) }
+            { result: response.body, usage: Helpers::Usage.from_response(response.body), status: response.status }
+          end
+
+          def generate_stream(model:, prompt: nil, images: nil, format: nil, options: nil, system: nil, keep_alive: nil, **, &block)
+            body = { model: model, prompt: prompt, images: images, format: format, options: options,
+                     system: system, stream: true, keep_alive: keep_alive }.compact
+            accumulated = +''
+            final_response = nil
+            buffer = +''
+
+            Helpers::Errors.with_retry do
+              streaming_client(**).post('/api/generate', body) do |req|
+                req.options.on_data = proc do |chunk, _size|
+                  buffer << chunk
+                  while (idx = buffer.index("\n"))
+                    line = buffer.slice!(0, idx + 1).strip
+                    next if line.empty?
+
+                    parsed = ::JSON.parse(line)
+                    if parsed['done']
+                      final_response = parsed
+                      block&.call({ type: :done, data: parsed })
+                    else
+                      text = parsed['response'] || ''
+                      accumulated << text
+                      block&.call({ type: :delta, text: text })
+                    end
+                  end
+                end
+              end
+            end
+
+            { result: accumulated, usage: Helpers::Usage.from_response(final_response), status: 200 }
           end
 
           include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&

data/lib/legion/extensions/ollama/runners/embeddings.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/ollama/helpers/client'
+require 'legion/extensions/ollama/helpers/errors'
 
 module Legion
   module Extensions
@@ -12,7 +13,7 @@ module Legion
           def embed(model:, input:, truncate: nil, options: nil, keep_alive: nil, dimensions: nil, **)
             body = { model: model, input: input, truncate: truncate, options: options,
                      keep_alive: keep_alive, dimensions: dimensions }.compact
-            response = client(**).post('/api/embed', body)
+            response = Helpers::Errors.with_retry { client(**).post('/api/embed', body) }
             { result: response.body, status: response.status }
           end
 

data/lib/legion/extensions/ollama/runners/models.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/ollama/helpers/client'
+require 'legion/extensions/ollama/helpers/errors'
 
 module Legion
   module Extensions
@@ -12,49 +13,51 @@ module Legion
           def create_model(model:, from: nil, files: nil, system: nil, stream: false, quantize: nil, **)
             body = { model: model, from: from, files: files, system: system,
                      stream: stream, quantize: quantize }.compact
-            response = client(**).post('/api/create', body)
+            response = Helpers::Errors.with_retry { client(**).post('/api/create', body) }
             { result: response.body, status: response.status }
           end
 
           def list_models(**)
-            response = client(**).get('/api/tags')
+            response = Helpers::Errors.with_retry { client(**).get('/api/tags') }
             { result: response.body, status: response.status }
           end
 
           def show_model(model:, verbose: nil, **)
             body = { model: model, verbose: verbose }.compact
-            response = client(**).post('/api/show', body)
+            response = Helpers::Errors.with_retry { client(**).post('/api/show', body) }
             { result: response.body, status: response.status }
           end
 
           def copy_model(source:, destination:, **)
             body = { source: source, destination: destination }
-            response = client(**).post('/api/copy', body)
+            response = Helpers::Errors.with_retry { client(**).post('/api/copy', body) }
             { result: response.status == 200, status: response.status }
           end
 
           def delete_model(model:, **)
             body = { model: model }
-            response = client(**).delete('/api/delete') do |req|
-              req.body = body
+            response = Helpers::Errors.with_retry do
+              client(**).delete('/api/delete') do |req|
+                req.body = body
+              end
             end
             { result: response.status == 200, status: response.status }
           end
 
           def pull_model(model:, insecure: nil, stream: false, **)
             body = { model: model, insecure: insecure, stream: stream }.compact
-            response = client(**).post('/api/pull', body)
+            response = Helpers::Errors.with_retry { client(**).post('/api/pull', body) }
             { result: response.body, status: response.status }
           end
 
           def push_model(model:, insecure: nil, stream: false, **)
             body = { model: model, insecure: insecure, stream: stream }.compact
-            response = client(**).post('/api/push', body)
+            response = Helpers::Errors.with_retry { client(**).post('/api/push', body) }
             { result: response.body, status: response.status }
           end
 
           def list_running(**)
-            response = client(**).get('/api/ps')
+            response = Helpers::Errors.with_retry { client(**).get('/api/ps') }
             { result: response.body, status: response.status }
           end
 

data/lib/legion/extensions/ollama/runners/version.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/ollama/helpers/client'
+require 'legion/extensions/ollama/helpers/errors'
 
 module Legion
   module Extensions
@@ -10,7 +11,7 @@ module Legion
           extend Legion::Extensions::Ollama::Helpers::Client
 
           def server_version(**)
-            response = client(**).get('/api/version')
+            response = Helpers::Errors.with_retry { client(**).get('/api/version') }
             { result: response.body, status: response.status }
           end
 

data/lib/legion/extensions/ollama/version.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Ollama
-      VERSION = '0.1.0'
+      VERSION = '0.2.0'
     end
   end
 end

data/lib/legion/extensions/ollama.rb

@@ -2,6 +2,8 @@
 
 require 'legion/extensions/ollama/version'
 require 'legion/extensions/ollama/helpers/client'
+require 'legion/extensions/ollama/helpers/errors'
+require 'legion/extensions/ollama/helpers/usage'
 require 'legion/extensions/ollama/runners/completions'
 require 'legion/extensions/ollama/runners/chat'
 require 'legion/extensions/ollama/runners/models'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-ollama
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Esity
@@ -44,6 +44,8 @@ files:
 - lib/legion/extensions/ollama.rb
 - lib/legion/extensions/ollama/client.rb
 - lib/legion/extensions/ollama/helpers/client.rb
+- lib/legion/extensions/ollama/helpers/errors.rb
+- lib/legion/extensions/ollama/helpers/usage.rb
 - lib/legion/extensions/ollama/runners/blobs.rb
 - lib/legion/extensions/ollama/runners/chat.rb
 - lib/legion/extensions/ollama/runners/completions.rb