lex-llm-ollama 0.2.10 → 0.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 367e593d0f98eed36e553e82356f0c86e37dd8e4a1324674c388f0383e59034d
-  data.tar.gz: f9d24ec554a9be7be90d33c76ddbb7d475a976c8158ceda71f596fcc8bfa42dd
+  metadata.gz: 98c1040c20dfe6ead193a404a6e34fda71e98188859f1e9c828a9778fff1b262
+  data.tar.gz: e5ce31cff8c62f5cab9ce6a59d33e90847bfbbe89e2d9445d8f51ce8540fe67c
 SHA512:
-  metadata.gz: 5be0235ede9a88b3b355cd2d6232c885332f6bcf8f5e0041922d496a76b5335c1533edd193b50c8ffe1f04953305b6527d7c60ac1a46b8d35d9cf28535902c36
-  data.tar.gz: cce2dd847b6fa13f1c8bf2c2a84df522315ed1d8af2f0e524e0564309a24494b4336432a57c60e3b2570402354923f1de805c7d721131d30939e633624f8aa4e
+  metadata.gz: cf3f73f8533cf2bd1145e3beffd12f602150eae3b4ad0031df24eaecac36bef6536d04e18a15b20cb2d6f529812a5cb63f2dfad28ed0638820a582f6e0ff37c9
+  data.tar.gz: da96da090f714b1d0811d475d091f637d4124931168039a2d0de2190b4022860e40a0c099819fb1d359c2ee055daba984d87a9748d9481e635fbe9673ea6eab6

data/lib/legion/extensions/llm/ollama/provider.rb

@@ -249,7 +249,7 @@ module Legion
               model: model_id,
               messages: format_messages(messages),
               stream: stream,
-              think: thinking ? true : nil,
+              think: thinking == true,
               keep_alive: ollama_keep_alive,
               format: schema_format(schema),
               options: { temperature: temperature }.compact,
@@ -258,6 +258,77 @@ module Legion
             }.compact
           end
 
+          def stream_response(connection, payload, additional_headers = {}, &block)
+            buffer = +''
+            chunks = []
+
+            connection.post(stream_url, payload) do |req|
+              req.headers = additional_headers.merge(req.headers) unless additional_headers.empty?
+              req.options.on_data = ndjson_handler(buffer, chunks, block)
+            end
+
+            finalize_stream(chunks)
+          end
+
+          def ndjson_handler(buffer, chunks, block)
+            proc do |chunk_data, _bytes, env|
+              next if env.respond_to?(:status) && env.status && env.status != 200
+
+              buffer << chunk_data.to_s
+              drain_ndjson_buffer(buffer, chunks, block)
+            end
+          end
+
+          def drain_ndjson_buffer(buffer, chunks, block)
+            while (idx = buffer.index("\n"))
+              line = buffer.slice!(0..idx).strip
+              next if line.empty?
+
+              parse_ndjson_line(line, chunks, block)
+            end
+          end
+
+          def parse_ndjson_line(line, chunks, block)
+            parsed = Legion::JSON.parse(line, symbolize_names: false)
+            return unless parsed.is_a?(Hash)
+
+            built = build_chunk(parsed)
+            chunks << built
+            block&.call(built)
+          rescue Legion::JSON::ParseError => e
+            handle_exception(e, level: :debug, handled: true, operation: 'ollama.stream_parse')
+          end
+
+          def finalize_stream(chunks)
+            return Legion::Extensions::Llm::Message.new(role: :assistant, content: nil) if chunks.empty?
+
+            Legion::Extensions::Llm::Message.new(
+              role: :assistant,
+              content: join_stream_content(chunks),
+              thinking: join_stream_thinking(chunks),
+              tool_calls: merge_stream_tool_calls(chunks),
+              model_id: chunks.last.model_id,
+              input_tokens: chunks.last.input_tokens,
+              output_tokens: chunks.last.output_tokens,
+              raw: chunks.last.raw
+            )
+          end
+
+          def join_stream_content(chunks)
+            text = chunks.filter_map { |c| c.content&.to_s }.join
+            text.empty? ? nil : text
+          end
+
+          def join_stream_thinking(chunks)
+            parts = chunks.filter_map { |c| c.thinking&.text }
+            Thinking.build(text: parts.empty? ? nil : parts.join)
+          end
+
+          def merge_stream_tool_calls(chunks)
+            merged = chunks.filter_map(&:tool_calls).reject(&:empty?).reduce({}, :merge)
+            merged.empty? ? nil : merged
+          end
+
           def format_messages(messages)
             messages.map do |message|
               content = message.content
@@ -312,11 +383,13 @@ module Legion
           def parse_completion_response(response)
             body = response.body
             message = body.fetch('message', {})
+            content, thinking = extract_thinking_from_completion(message)
             Legion::Extensions::Llm::Message.new(
               role: :assistant,
-              content: message['content'],
+              content: content,
               model_id: body['model'],
               tool_calls: parse_tool_calls(message['tool_calls']),
+              thinking: thinking,
               input_tokens: body['prompt_eval_count'],
               output_tokens: body['eval_count'],
               raw: body
@@ -325,9 +398,12 @@ module Legion
 
           def build_chunk(data)
             message = data.fetch('message', {})
+            thinking = message['thinking']
             Legion::Extensions::Llm::Chunk.new(
               role: :assistant,
               content: message['content'],
+              thinking: thinking ? Thinking.build(text: thinking) : nil,
+              tool_calls: parse_tool_calls(message['tool_calls']),
               model_id: data['model'],
               input_tokens: data['prompt_eval_count'],
               output_tokens: data['eval_count'],
@@ -335,6 +411,22 @@ module Legion
             )
           end
 
+          def extract_thinking_from_completion(message)
+            extraction = Responses::ThinkingExtractor.extract(
+              message['content'],
+              metadata: thinking_metadata(message)
+            )
+
+            [
+              extraction.content,
+              Thinking.build(text: extraction.thinking, signature: extraction.signature)
+            ]
+          end
+
+          def thinking_metadata(message)
+            { thinking: message['thinking'] }.compact
+          end
+
           def parse_tool_calls(tool_calls)
             return nil unless tool_calls
 

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Ollama
-        VERSION = '0.2.10'
+        VERSION = '0.2.11'
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-ollama
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.2.11
 platform: ruby
 authors:
 - LegionIO