last_llm 0.0.4

data/lib/last_llm/providers/ollama.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'last_llm/providers/constants'
+
+# Ollama provider implementation
+class Ollama < LastLLM::Provider
+  BASE_ENDPOINT = 'http://172.17.0.1:11434'
+
+  def initialize(config)
+    super(Constants::OLLAMA, config)
+    @conn = connection(config[:base_url] || BASE_ENDPOINT)
+  end
+
+  def generate_text(prompt, options = {})
+    messages = format_messages(prompt, options)
+
+    response = @conn.post('/v1/chat/completions') do |req|
+      req.body = {
+        model: options[:model] || @config[:model] || 'llama3.2:latest',
+        messages: messages,
+        temperature: options[:temperature] || 0.7,
+        top_p: options[:top_p] || 0.7,
+        max_tokens: options[:max_tokens] || 24_576,
+        stream: false
+      }.compact
+    end
+
+    result = parse_response(response)
+    content = result.dig(:choices, 0, :message, :content)
+
+    content.to_s
+  rescue Faraday::Error => e
+    handle_request_error(e)
+  end
+
+  def generate_object(prompt, schema, options = {})
+    system_prompt = 'You are a helpful assistant that responds with valid JSON.'
+    formatted_prompt = LastLLM::StructuredOutput.format_prompt(prompt, schema)
+
+    messages = [
+      { role: 'system', content: system_prompt },
+      { role: 'user', content: formatted_prompt }
+    ]
+
+    response = @conn.post('/v1/chat/completions') do |req|
+      req.body = {
+        model: options[:model] || @config[:model] || 'llama3.2:latest',
+        messages: messages,
+        temperature: options[:temperature] || 0.2,
+        stream: false
+      }.compact
+    end
+
+    result = parse_response(response)
+    content = result.dig(:choices, 0, :message, :content)
+
+    begin
+      JSON.parse(content, symbolize_names: true)
+    rescue JSON::ParserError => e
+      raise LastLLM::ApiError, "Invalid JSON response: #{e.message}"
+    end
+  rescue Faraday::Error => e
+    handle_request_error(e)
+  end
+
+  private
+
+  def format_messages(prompt, options)
+    if prompt.is_a?(Array) && prompt.all? { |m| m.is_a?(Hash) && m[:role] && m[:content] }
+      prompt
+    elsif options[:system_prompt]
+      [
+        { role: 'system', content: options[:system_prompt] },
+        { role: 'user', content: prompt.to_s }
+      ]
+    else
+      [{ role: 'user', content: prompt.to_s }]
+    end
+  end
+
+  # Format a tool for Ollama function calling
+  # @param tool [LastLLM::Tool] The tool to format
+  # @return [Hash] The tool in Ollama format
+  def self.format_tool(tool)
+    {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    }
+  end
+
+  # Execute a tool from an Ollama response
+  # @param tool [LastLLM::Tool] The tool to execute
+  # @param response [Hash] The Ollama response containing tool call information
+  # @return [Hash, nil] The result of the function call or nil if the tool wasn't called
+  def self.execute_tool(tool, response)
+    # Ollama doesn't have native function calling, so we need to parse from the content
+    # This is a simplified implementation that would need to be enhanced for production
+    content = response.dig(:message, :content)
+    return nil unless content&.include?(tool.name)
+
+    # Simple regex to extract JSON from the content
+    # This is a basic implementation and might need enhancement
+    if content =~ /#{tool.name}\s*\(([^)]+)\)/i
+      args_str = ::Regexp.last_match(1)
+      begin
+        args = JSON.parse("{#{args_str}}", symbolize_names: true)
+        return tool.call(args)
+      rescue JSON::ParserError
+        return nil
+      end
+    end
+
+    nil
+  end
+end
+
+# Also define it in the LastLLM::Providers namespace for consistency
+module LastLLM
+  module Providers
+    # Reference to the Ollama class defined above
+    Ollama = ::Ollama
+  end
+end

data/lib/last_llm/providers/openai.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require 'last_llm/providers/constants'
+
+# OpenAI provider implementation
+class OpenAI < LastLLM::Provider
+  BASE_ENDPOINT = 'https://api.openai.com'
+
+  def initialize(config)
+    super(Constants::OPENAI, config)
+    @conn = connection(config[:base_url] || BASE_ENDPOINT)
+  end
+
+  def generate_text(prompt, options = {})
+    request_body = build_completion_request(prompt, options)
+    response = make_completion_request(request_body)
+    extract_content(response)
+  rescue Faraday::Error => e
+    handle_request_error(e)
+  end
+
+  def generate_object(prompt, schema, options = {})
+    request_body = build_json_request(prompt, schema, options)
+    response = make_completion_request(request_body)
+    parse_json_response(response)
+  rescue Faraday::Error => e
+    handle_request_error(e)
+  end
+
+  # Generate embeddings from text
+  # @param text [String] The text to generate embeddings for
+  # @param options [Hash] Options for the embedding generation
+  # @return [Array<Float>] The embedding vector as an array of floats
+  def embeddings(text, options = {})
+    # Ensure text is a string
+    text_str = text.to_s
+
+    response = @conn.post('/v1/embeddings') do |req|
+      req.body = {
+        model: options[:model] || 'text-embedding-ada-002',
+        input: text_str,
+        encoding_format: options[:encoding_format] || 'float'
+      }.compact
+    end
+
+    result = parse_response(response)
+
+    # Extract embeddings from response
+    embeddings = result.dig(:data, 0, :embedding)
+
+    raise LastLLM::ApiError.new('Invalid embeddings response format', nil) unless embeddings.is_a?(Array)
+
+    embeddings
+  rescue Faraday::Error => e
+    handle_request_error(e)
+  end
+
+  private
+
+  def build_completion_request(prompt, options)
+    {
+      model: options[:model] || @config[:model] || 'gpt-4o-mini',
+      messages: format_messages(prompt, options),
+      temperature: options[:temperature] || 0.7,
+      top_p: options[:top_p] || 0.7,
+      max_tokens: options[:max_tokens] || 4096,
+      stream: false
+    }.compact
+  end
+
+  def build_json_request(prompt, schema, options)
+    {
+      model: options[:model] || @config[:model] || 'gpt-4o-mini',
+      messages: format_json_messages(prompt, schema),
+      temperature: options[:temperature] || 0.2,
+      top_p: options[:top_p] || 0.7,
+      max_tokens: options[:max_tokens] || 8_192,
+      response_format: { type: 'json_object' },
+      stream: false
+    }.compact
+  end
+
+  def make_completion_request(body)
+    @conn.post('/v1/chat/completions') do |req|
+      req.body = body
+    end
+  end
+
+  def format_json_messages(prompt, schema)
+    system_prompt = 'You are a helpful assistant that responds with valid JSON.'
+    formatted_prompt = LastLLM::StructuredOutput.format_prompt(prompt, schema)
+
+    [
+      { role: 'system', content: system_prompt },
+      { role: 'user', content: formatted_prompt }
+    ]
+  end
+
+  def format_messages(prompt, options)
+    if prompt.is_a?(Array) && prompt.all? { |m| m.is_a?(Hash) && m[:role] && m[:content] }
+      prompt
+    elsif options[:system_prompt]
+      [
+        { role: 'system', content: options[:system_prompt] },
+        { role: 'user', content: prompt.to_s }
+      ]
+    else
+      [{ role: 'user', content: prompt.to_s }]
+    end
+  end
+
+  def extract_content(response)
+    result = parse_response(response)
+    result.dig(:choices, 0, :message, :content).to_s
+  end
+
+  def parse_json_response(response)
+    content = extract_content(response)
+    parsed_json = JSON.parse(content, symbolize_names: true)
+
+    if parsed_json.key?(:$schema) && parsed_json.key?(:properties)
+      parsed_json[:properties]
+    else
+      parsed_json
+    end
+  rescue JSON::ParserError => e
+    raise LastLLM::ApiError, "Invalid JSON response: #{e.message}"
+  end
+
+  def parse_response(response)
+    parsed = if response.body.is_a?(Hash)
+               response.body
+             else
+               JSON.parse(response.body)
+             end
+
+    validate_response(parsed)
+    deep_symbolize_keys(parsed)
+  rescue JSON::ParserError => e
+    raise LastLLM::ApiError.new("Failed to parse OpenAI response: #{e.message}", nil)
+  end
+
+  def validate_response(parsed)
+    if parsed.nil? || (!parsed.is_a?(Hash) && !parsed.respond_to?(:to_h))
+      raise LastLLM::ApiError.new('Invalid response format from OpenAI', nil)
+    end
+
+    raise LastLLM::ApiError.new(parsed[:error][:message], parsed[:error][:code]) if parsed[:error]
+  end
+
+  def handle_request_error(error)
+    message = "OpenAI API request failed: #{error.message}"
+    status = error.respond_to?(:response) && error.response.respond_to?(:status) ? error.response.status : nil
+    raise LastLLM::ApiError.new(message, status)
+  end
+
+  # Format a tool for OpenAI function calling
+  def self.format_tool(tool)
+    {
+      type: 'function',
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters
+      }
+    }
+  end
+
+  # Execute a tool from an OpenAI response
+  def self.execute_tool(tool, response)
+    tool_call = response[:tool_calls]&.first
+    return nil unless tool_call && tool_call[:function][:name] == tool.name
+
+    arguments = JSON.parse(tool_call[:function][:arguments], symbolize_names: true)
+    tool.call(arguments)
+  end
+end
+
+# Also define it in the LastLLM::Providers namespace for consistency
+module LastLLM
+  module Providers
+    OpenAI = ::OpenAI
+  end
+end

data/lib/last_llm/providers/test_provider.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'last_llm/providers/constants'
+
+# A provider implementation for testing purposes
+class TestProvider < LastLLM::Provider
+  attr_accessor :text_response, :object_response
+
+  def initialize(config = {})
+    # Skip parent's initialize which checks for API key
+    # Instead implement our own initialization
+    @config = config.is_a?(Hash) ? config : {}
+    @name = Constants::TEST
+    @text_response = 'Test response'
+    @object_response = {}
+  end
+
+  # Override validate_config! to not require API key
+  def validate_config!
+    # No validation needed for test provider
+  end
+
+  def generate_text(_prompt, _options = {})
+    @text_response
+  end
+
+  def generate_object(_prompt, _schema, _options = {})
+    @object_response
+  end
+end
+
+# Also define it in the LastLLM::Providers namespace for consistency
+module LastLLM
+  module Providers
+    # Reference to the TestProvider class defined above
+    TestProvider = ::TestProvider
+  end
+end

data/lib/last_llm/railtie.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'rails'
+
+# This file defines the Railtie constant directly to be compatible with Zeitwerk
+# Rails integration for LastLLM
+class Railtie < Rails::Railtie
+  generators do
+    require 'generators/last_llm/install/install_generator'
+  end
+
+  initializer 'last_llm.configure_rails_initialization' do
+    # Load configuration from config/last_llm.yml if it exists
+    config_file = Rails.root.join('config', 'last_llm.yml')
+    if File.exist?(config_file)
+      config = YAML.safe_load_file(config_file, symbolize_names: true)
+
+      # Configure LastLLM with the loaded configuration
+      LastLLM.configure do |c|
+        # Set global configuration
+        c.default_provider = config[:default_provider].to_sym if config[:default_provider]
+
+        c.default_model = config[:default_model] if config[:default_model]
+
+        # Configure global settings
+        config[:globals]&.each do |key, value|
+          c.set_global(key.to_sym, value)
+        end
+      end
+    end
+  end
+end
+
+# Also define it in the LastLLM namespace for backward compatibility
+module LastLLM
+  # Reference to the Railtie class defined above
+  Railtie = ::Railtie
+end

data/lib/last_llm/schema.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require 'dry-schema'
+require 'json'
+
+module LastLLM
+  # Schema utilities for structured data generation
+  class Schema
+    # Create a dry-schema from a hash definition
+    # @param schema_def [Hash] The schema definition in JSON Schema format
+    # @return [Dry::Schema::JSON] The created schema
+    def self.create(schema_def)
+      # Convert JSON Schema to dry-schema
+      Dry::Schema.JSON do
+        # Process properties
+        if schema_def[:properties] || schema_def['properties']
+          properties = schema_def[:properties] || schema_def['properties']
+          required = schema_def[:required] || schema_def['required'] || []
+
+          properties.each do |property_name, property_def|
+            property_name = property_name.to_sym
+            property_type = property_def[:type] || property_def['type']
+
+            # Handle required properties
+            if required.include?(property_name.to_s)
+              # Handle different property types
+              case property_type
+              when 'string'
+                required(property_name).filled(:string)
+              when 'integer'
+                required(property_name).filled(:integer)
+              when 'number'
+                required(property_name).filled(:float)
+              when 'boolean'
+                required(property_name).filled(:bool)
+              when 'array'
+                items_type = property_def.dig(:items, :type) || property_def.dig('items', 'type')
+                case items_type
+                when 'string'
+                  required(property_name).array(:string)
+                when 'integer'
+                  required(property_name).array(:integer)
+                when 'number'
+                  required(property_name).array(:float)
+                when 'boolean'
+                  required(property_name).array(:bool)
+                when 'object'
+                  # For complex nested objects, we'd need a more sophisticated approach
+                  # This is a simplified version
+                  required(property_name).array(:hash)
+                else
+                  required(property_name).array
+                end
+              when 'object'
+                # For nested objects, we can't recursively create a schema here
+                # Instead, we'll just create a hash schema
+                required(property_name).hash do
+                  # Add nested properties if available
+                  if property_def[:properties] || property_def['properties']
+                    nested_props = property_def[:properties] || property_def['properties']
+                    nested_required = property_def[:required] || property_def['required'] || []
+
+                    nested_props.each do |nested_name, nested_def|
+                      nested_name = nested_name.to_sym
+                      nested_type = nested_def[:type] || nested_def['type']
+
+                      if nested_required.include?(nested_name.to_s)
+                        case nested_type
+                        when 'string'
+                          required(nested_name).filled(:string)
+                        when 'integer'
+                          required(nested_name).filled(:integer)
+                        when 'number'
+                          required(nested_name).filled(:float)
+                        when 'boolean'
+                          required(nested_name).filled(:bool)
+                        else
+                          required(nested_name).filled
+                        end
+                      else
+                        optional(nested_name)
+                      end
+                    end
+                  end
+                end
+              else
+                required(property_name).filled
+              end
+            else
+              # Handle optional properties
+              case property_type
+              when 'string'
+                optional(property_name).maybe(:string)
+              when 'integer'
+                optional(property_name).maybe(:integer)
+              when 'number'
+                optional(property_name).maybe(:float)
+              when 'boolean'
+                optional(property_name).maybe(:bool)
+              when 'array'
+                items_type = property_def.dig(:items, :type) || property_def.dig('items', 'type')
+                case items_type
+                when 'string'
+                  optional(property_name).maybe(:array, :string)
+                when 'integer'
+                  optional(property_name).maybe(:array, :integer)
+                when 'number'
+                  optional(property_name).maybe(:array, :float)
+                when 'boolean'
+                  optional(property_name).maybe(:array, :bool)
+                when 'object'
+                  optional(property_name).maybe(:array, :hash)
+                else
+                  optional(property_name).maybe(:array)
+                end
+              when 'object'
+                # For nested objects, we can't recursively create a schema here
+                # Instead, we'll just create a hash schema
+                optional(property_name).maybe(:hash) do
+                  # Add nested properties if available
+                  if property_def[:properties] || property_def['properties']
+                    nested_props = property_def[:properties] || property_def['properties']
+                    nested_required = property_def[:required] || property_def['required'] || []
+
+                    nested_props.each do |nested_name, nested_def|
+                      nested_name = nested_name.to_sym
+                      nested_type = nested_def[:type] || nested_def['type']
+
+                      if nested_required.include?(nested_name.to_s)
+                        case nested_type
+                        when 'string'
+                          required(nested_name).filled(:string)
+                        when 'integer'
+                          required(nested_name).filled(:integer)
+                        when 'number'
+                          required(nested_name).filled(:float)
+                        when 'boolean'
+                          required(nested_name).filled(:bool)
+                        else
+                          required(nested_name).filled
+                        end
+                      else
+                        optional(nested_name)
+                      end
+                    end
+                  end
+                end
+              else
+                optional(property_name)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # Convert a JSON schema string to a dry-schema
+    # @param json_schema [String] The JSON schema as a string
+    # @return [Dry::Schema::JSON] The created schema
+    def self.from_json_schema(json_schema)
+      schema_def = JSON.parse(json_schema, symbolize_names: true)
+      create(schema_def)
+    end
+
+    # Convert a dry-schema to a JSON schema string
+    # @param schema [Dry::Schema::JSON, Hash] The dry-schema or JSON schema hash to convert
+    # @return [String] The JSON schema as a string
+    def self.to_json_schema(schema)
+      # If schema is already a Hash, assume it's a JSON schema
+      return JSON.pretty_generate(schema) if schema.is_a?(Hash)
+
+      # If schema has a json_schema method, use it
+      return JSON.pretty_generate(schema.json_schema) if schema.respond_to?(:json_schema)
+
+      # Otherwise, extract schema information from dry-schema
+      json_schema = {
+        type: 'object',
+        properties: {},
+        required: []
+      }
+
+      # Process each rule in the schema
+      if schema.respond_to?(:rules) && schema.rules.respond_to?(:each_value)
+        schema.rules.each_value do |rule|
+          # Skip if rule is not a proper rule object
+          next unless rule.respond_to?(:name)
+
+          property_name = rule.name.to_s
+          property_def = {}
+
+          # Determine if the property is required
+          json_schema[:required] << property_name if rule.is_a?(Dry::Schema::Rule::Required)
+
+          # Determine the property type
+          if rule.respond_to?(:type) && rule.type.is_a?(Dry::Types::Nominal)
+            case rule.type.primitive
+            when String
+              property_def['type'] = 'string'
+            when Integer
+              property_def['type'] = 'integer'
+            when Float
+              property_def['type'] = 'number'
+            when TrueClass, FalseClass
+              property_def['type'] = 'boolean'
+            when Array
+              property_def['type'] = 'array'
+              # Try to determine the item type
+              property_def['items'] = if rule.type.respond_to?(:member) && rule.type.member.respond_to?(:primitive)
+                                        case rule.type.member.primitive
+                                        when String
+                                          { 'type' => 'string' }
+                                        when Integer
+                                          { 'type' => 'integer' }
+                                        when Float
+                                          { 'type' => 'number' }
+                                        when TrueClass, FalseClass
+                                          { 'type' => 'boolean' }
+                                        when Hash
+                                          { 'type' => 'object' }
+                                        else
+                                          {}
+                                        end
+                                      else
+                                        {}
+                                      end
+            when Hash
+              property_def['type'] = 'object'
+              # For nested objects, we'd need a more sophisticated approach
+            else
+              property_def['type'] = 'string' # Default to string
+            end
+          end
+
+          json_schema[:properties][property_name] = property_def
+        end
+      end
+
+      JSON.pretty_generate(json_schema)
+    end
+  end
+end

data/lib/last_llm/structured_output.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module LastLLM
+  # Class for generating structured data from LLM providers
+  class StructuredOutput
+    # Initialize a new structured output generator
+    # @param client [LastLLM::Client] The client to use for generation
+    def initialize(client)
+      @client = client
+    end
+
+    # Generate a structured object from a prompt
+    # @param prompt [String] The prompt to generate the object from
+    # @param schema [Dry::Schema::JSON] The schema to validate against
+    # @param options [Hash] Generation options
+    # @option options [String] :model The model to use
+    # @option options [Float] :temperature (0.2) The temperature to use
+    # @return [Hash] The generated object
+    # @raise [ValidationError] If the generated object fails validation
+    def generate(prompt, schema, options = {})
+      # Format the prompt with schema information
+      formatted_prompt = self.class.format_prompt(prompt, schema)
+
+      # Set a lower temperature by default for structured data
+      options = { temperature: 0.2 }.merge(options)
+
+      # Generate the object using the provider
+      result = @client.provider.generate_object(formatted_prompt, schema, options)
+
+      # Validate the result against the schema
+      validation = schema.call(result)
+
+      raise ValidationError, "Generated object failed validation: #{validation.errors.to_h}" unless validation.success?
+
+      result
+    end
+
+    # Format a prompt with schema information
+    # @param prompt [String] The original prompt
+    # @param schema [Dry::Schema::JSON] The schema to include
+    # @return [String] The formatted prompt
+    def self.format_prompt(prompt, schema)
+      schema_json = Schema.to_json_schema(schema)
+
+      <<~PROMPT
+        #{prompt}
+
+        Respond with valid JSON that matches the following schema:
+
+        #{schema_json}
+
+        Ensure your response is a valid JSON object that strictly follows this schema.
+      PROMPT
+    end
+  end
+end