lex-llm 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40556884bda9b7daeff510f1ee58532cfcecb01c30b942bbc17637ae2eb1aa14
-  data.tar.gz: 4a1448028063a4976a4dab4c5058927b3e79b4c2bbff897c44075e90c879097e
+  metadata.gz: bba21b096146376e92e11aa2a001e7f13cd91e453ecd2907c44cc1c39dcbe3a1
+  data.tar.gz: ad320998555a6e6f8eda82b0dac1bc376415def07c15228400c60f0638a82b1c
 SHA512:
-  metadata.gz: 156e17beda598522ff95facb2eae951ccc2cc13693e4f4f11346e6f403cf73f76e358f4ef57518f2ad92dff9e63cddbc04510c9a3fce18789d90ed062084b629
-  data.tar.gz: adb0fca5733239dc70894d2fc606da5dc2018d4ba83f47e1cf645048c2a956d3a3da6a7f08cd946c8dfc1e473c29cbeb83675f2e452a40fb53302f5df770a8e0
+  metadata.gz: 7b657bf222fa57ad9bd887d6e964a9bb1664c732b894dc760f33fe5396b44c136a19ae96d859036c63449f307f6eb613ef27862ace25fd634a95dafb9c3b5c96
+  data.tar.gz: f1799aba3ec971591f68e7cfe6ad144742acd82582af1e44de251d3ada828773e64f2b617be9482f7fc31c15e2f2a22861630d5383e614565465d6ae050e9e5e

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.1.2 - 2026-04-27
+
+- Add a shared OpenAI-compatible provider adapter for `lex-llm-openai`, `lex-llm-vllm`, `lex-llm-mlx`, and other compatible servers.
+
 ## 0.1.1 - 2026-04-27
 
 - Remove fork-carried concrete provider implementations and VCR-backed provider specs from the base gem.

data/lib/lex_llm/provider/open_ai_compatible.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module LexLLM
+  class Provider
+    # Shared OpenAI-compatible HTTP payload and response adapter.
+    module OpenAICompatible
+      def completion_url = '/v1/chat/completions'
+      def stream_url = completion_url
+      def models_url = '/v1/models'
+      def moderation_url = '/v1/moderations'
+      def embedding_url(**) = '/v1/embeddings'
+      def transcription_url = '/v1/audio/transcriptions'
+
+      def images_url(with:, mask:)
+        with || mask ? '/v1/images/edits' : '/v1/images/generations'
+      end
+
+      private
+
+      def render_payload(messages, tools:, temperature:, model:, stream:, schema:, thinking:, tool_prefs:) # rubocop:disable Metrics/ParameterLists
+        {
+          model: model.id,
+          messages: format_openai_messages(messages),
+          temperature: temperature,
+          stream: stream,
+          tools: format_openai_tools(tools),
+          tool_choice: openai_tool_choice(tool_prefs),
+          response_format: openai_response_format(schema),
+          reasoning_effort: openai_reasoning_effort(thinking)
+        }.compact
+      end
+
+      def format_openai_messages(messages)
+        messages.map do |message|
+          {
+            role: message.role.to_s,
+            content: openai_content(message.content),
+            tool_call_id: message.tool_call_id,
+            tool_calls: format_openai_tool_calls(message.tool_calls)
+          }.compact
+        end
+      end
+
+      def openai_content(content)
+        return content.format if content.is_a?(LexLLM::Content::Raw)
+        return content unless content.respond_to?(:attachments)
+        return content.text.to_s if content.attachments.empty?
+
+        openai_content_parts(content)
+      end
+
+      def openai_content_parts(content)
+        parts = []
+        parts << { type: 'text', text: content.text.to_s } if content.text
+        content.attachments.each do |attachment|
+          parts << { type: 'image_url', image_url: { url: attachment.for_llm } } if attachment.image?
+        end
+        parts
+      end
+
+      def format_openai_tool_calls(tool_calls)
+        return nil unless tool_calls&.any?
+
+        tool_calls.values.map do |tool_call|
+          {
+            id: tool_call.id,
+            type: 'function',
+            function: {
+              name: tool_call.name,
+              arguments: Legion::JSON.generate(tool_call.arguments || {})
+            }
+          }
+        end
+      end
+
+      def format_openai_tools(tools)
+        return nil if tools.empty?
+
+        tools.values.map do |tool|
+          {
+            type: 'function',
+            function: {
+              name: tool.name,
+              description: tool.description,
+              parameters: tool.params_schema || { type: 'object', properties: {} }
+            }
+          }
+        end
+      end
+
+      def openai_tool_choice(tool_prefs)
+        choice = tool_prefs && (tool_prefs[:choice] || tool_prefs['choice'])
+        return nil unless choice
+        return choice.to_s if %i[auto none required].include?(choice.to_sym)
+
+        { type: 'function', function: { name: choice.to_s } }
+      end
+
+      def openai_response_format(schema)
+        return nil unless schema
+
+        schema_hash = schema.respond_to?(:to_h) ? schema.to_h : schema
+        { type: 'json_schema', json_schema: schema_hash }
+      end
+
+      def openai_reasoning_effort(thinking)
+        return nil unless thinking.is_a?(Hash)
+
+        thinking[:effort] || thinking['effort']
+      end
+
+      def parse_completion_response(response)
+        body = response.body
+        choice = Array(body['choices']).first || {}
+        message = choice['message'] || {}
+        usage = body['usage'] || {}
+
+        LexLLM::Message.new(
+          role: :assistant,
+          content: message['content'],
+          model_id: body['model'],
+          tool_calls: parse_tool_calls(message['tool_calls']),
+          input_tokens: usage['prompt_tokens'],
+          output_tokens: usage['completion_tokens'],
+          reasoning_tokens: usage.dig('completion_tokens_details', 'reasoning_tokens'),
+          raw: body
+        )
+      end
+
+      def build_chunk(data)
+        choice = Array(data['choices']).first || {}
+        delta = choice['delta'] || {}
+        usage = data['usage'] || {}
+
+        LexLLM::Chunk.new(
+          role: :assistant,
+          content: delta['content'],
+          model_id: data['model'],
+          tool_calls: parse_tool_calls(delta['tool_calls']),
+          input_tokens: usage['prompt_tokens'],
+          output_tokens: usage['completion_tokens'],
+          raw: data
+        )
+      end
+
+      def parse_tool_calls(tool_calls)
+        return nil unless tool_calls&.any?
+
+        tool_calls.to_h do |call|
+          function = call.fetch('function', {})
+          name = function.fetch('name')
+          [name.to_sym, LexLLM::ToolCall.new(id: call['id'] || name, name: name,
+                                             arguments: parse_tool_arguments(function['arguments']))]
+        end
+      end
+
+      def parse_tool_arguments(arguments)
+        return {} if arguments.nil? || arguments == ''
+        return arguments if arguments.is_a?(Hash)
+
+        Legion::JSON.parse(arguments, symbolize_names: false)
+      rescue Legion::JSON::ParseError
+        {}
+      end
+
+      def parse_list_models_response(response, provider, _capabilities)
+        response.body.fetch('data', []).map do |model|
+          LexLLM::Model::Info.new(
+            id: model.fetch('id'),
+            name: model['id'],
+            provider: provider,
+            created_at: model['created'],
+            metadata: model
+          )
+        end
+      end
+
+      def render_embedding_payload(text, model:, dimensions:)
+        { model: model, input: text, dimensions: dimensions }.compact
+      end
+
+      def parse_embedding_response(response, model:, text:)
+        vectors = response.body.fetch('data', []).map { |item| item['embedding'] }
+        vectors = vectors.first unless text.is_a?(Array)
+        usage = response.body['usage'] || {}
+
+        LexLLM::Embedding.new(vectors: vectors, model: model, input_tokens: usage['prompt_tokens'].to_i)
+      end
+
+      def render_moderation_payload(input, model:)
+        { model: model, input: input }.compact
+      end
+
+      def parse_moderation_response(response, model:)
+        LexLLM::Moderation.new(id: response.body['id'], model: response.body['model'] || model,
+                               results: response.body.fetch('results', []))
+      end
+
+      def render_image_payload(prompt, model:, size:, with:, mask:, params:) # rubocop:disable Metrics/ParameterLists
+        { model: model, prompt: prompt, size: size, image: with, mask: mask }.merge(params).compact
+      end
+
+      def parse_image_response(response, model:)
+        image = response.body.fetch('data', []).first || {}
+        LexLLM::Image.new(url: image['url'], data: image['b64_json'], revised_prompt: image['revised_prompt'],
+                          model_id: model, usage: response.body['usage'] || {})
+      end
+
+      def render_transcription_payload(file_part, model:, language:, **options)
+        { model: model, file: file_part, language: language }.merge(options).compact
+      end
+
+      def parse_transcription_response(response, model:)
+        LexLLM::Transcription.new(text: response.body['text'], model: model, language: response.body['language'],
+                                  duration: response.body['duration'], segments: response.body['segments'])
+      end
+    end
+  end
+end

data/lib/lex_llm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LexLLM
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/lib/lex_llm.rb

@@ -22,6 +22,7 @@ module LexLLM
     'UI' => 'UI',
     'api' => 'API',
     'llm' => 'LLM',
+    'open_ai_compatible' => 'OpenAICompatible',
     'pdf' => 'PDF',
     'lex_llm' => 'LexLLM'
   )

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - LegionIO
@@ -305,6 +305,7 @@ files:
 - lib/lex_llm/models_schema.json
 - lib/lex_llm/moderation.rb
 - lib/lex_llm/provider.rb
+- lib/lex_llm/provider/open_ai_compatible.rb
 - lib/lex_llm/railtie.rb
 - lib/lex_llm/routing.rb
 - lib/lex_llm/routing/lane_key.rb