ollama-client 0.2.5 → 0.2.6

data/examples/dhanhq/test_tool_calling_verbose.rb

@@ -1,251 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# DhanHQ Tool Calling Test - Verbose Version
-# Shows the complete tool calling flow: LLM decides → Executor executes
-
-require_relative "../../lib/ollama_client"
-require_relative "../dhanhq_tools"
-
-puts "\n=== DHANHQ TOOL CALLING TEST (VERBOSE) ===\n"
-puts "This demonstrates REAL tool calling:\n"
-puts "  1. LLM receives user query + tool definitions"
-puts "  2. LLM DECIDES which tools to call (not your code!)"
-puts "  3. LLM returns tool_calls in response"
-puts "  4. Executor detects tool_calls and executes callables"
-puts "  5. Tool results fed back to LLM"
-puts "  6. LLM generates final answer\n"
-
-# Configure DhanHQ
-begin
-  DhanHQ.configure_with_env
-  puts "✅ DhanHQ configured\n"
-rescue StandardError => e
-  puts "⚠️  DhanHQ configuration error: #{e.message}\n"
-end
-
-# Create client
-config = Ollama::Config.new
-config.model = ENV.fetch("OLLAMA_MODEL", "llama3.1:8b")
-config.temperature = 0.2
-config.timeout = 60
-client = Ollama::Client.new(config: config)
-
-# Define tools
-market_quote_tool = Ollama::Tool.new(
-  type: "function",
-  function: Ollama::Tool::Function.new(
-    name: "get_market_quote",
-    description: "Get market quote for a symbol",
-    parameters: Ollama::Tool::Function::Parameters.new(
-      type: "object",
-      properties: {
-        symbol: Ollama::Tool::Function::Parameters::Property.new(
-          type: "string",
-          description: "Stock symbol"
-        ),
-        exchange_segment: Ollama::Tool::Function::Parameters::Property.new(
-          type: "string",
-          description: "Exchange segment",
-          enum: %w[NSE_EQ BSE_EQ IDX_I]
-        )
-      },
-      required: %w[symbol exchange_segment]
-    )
-  )
-)
-
-live_ltp_tool = Ollama::Tool.new(
-  type: "function",
-  function: Ollama::Tool::Function.new(
-    name: "get_live_ltp",
-    description: "Get live last traded price",
-    parameters: Ollama::Tool::Function::Parameters.new(
-      type: "object",
-      properties: {
-        symbol: Ollama::Tool::Function::Parameters::Property.new(
-          type: "string",
-          description: "Stock symbol"
-        ),
-        exchange_segment: Ollama::Tool::Function::Parameters::Property.new(
-          type: "string",
-          description: "Exchange segment",
-          enum: %w[NSE_EQ BSE_EQ IDX_I]
-        )
-      },
-      required: %w[symbol exchange_segment]
-    )
-  )
-)
-
-option_chain_tool = Ollama::Tool.new(
-  type: "function",
-  function: Ollama::Tool::Function.new(
-    name: "get_option_chain",
-    description: "Get option chain for an index (NIFTY, SENSEX, BANKNIFTY). " \
-                 "Returns available expiries and option chain data with strikes, Greeks, OI, and IV.",
-    parameters: Ollama::Tool::Function::Parameters.new(
-      type: "object",
-      properties: {
-        symbol: Ollama::Tool::Function::Parameters::Property.new(
-          type: "string",
-          description: "Index symbol (NIFTY, SENSEX, or BANKNIFTY)",
-          enum: %w[NIFTY SENSEX BANKNIFTY]
-        ),
-        exchange_segment: Ollama::Tool::Function::Parameters::Property.new(
-          type: "string",
-          description: "Exchange segment (must be IDX_I for indices)",
-          enum: %w[IDX_I]
-        ),
-        expiry: Ollama::Tool::Function::Parameters::Property.new(
-          type: "string",
-          description: "Optional expiry date (YYYY-MM-DD format). If not provided, returns available expiries list."
-        )
-      },
-      required: %w[symbol exchange_segment]
-    )
-  )
-)
-
-# Define callables (these are just implementations - LLM decides when to call them)
-tools = {
-  "get_option_chain" => {
-    tool: option_chain_tool,
-    callable: lambda do |symbol:, exchange_segment:, expiry: nil|
-      # Normalize empty string to nil (LLM might pass "" when expiry is optional)
-      expiry = nil if expiry.is_a?(String) && expiry.empty?
-      puts "\n  [TOOL EXECUTION] get_option_chain called by Executor"
-      puts "    Args: symbol=#{symbol}, exchange_segment=#{exchange_segment}, expiry=#{expiry || 'nil'}"
-      puts "    Note: This is called AFTER LLM decided to use this tool!"
-      result = DhanHQDataTools.get_option_chain(
-        symbol: symbol.to_s,
-        exchange_segment: exchange_segment.to_s,
-        expiry: expiry
-      )
-      if result[:error]
-        { error: result[:error] }
-      elsif result[:result] && result[:result][:expiries]
-        # Return expiry list
-        {
-          symbol: symbol,
-          expiries_available: result[:result][:expiries],
-          count: result[:result][:count]
-        }
-      elsif result[:result] && result[:result][:chain]
-        # Return option chain data
-        chain = result[:result][:chain]
-        strikes = chain.is_a?(Hash) ? chain.keys.sort_by(&:to_f) : []
-        {
-          symbol: symbol,
-          expiry: result[:result][:expiry],
-          underlying_price: result[:result][:underlying_last_price],
-          strikes_count: strikes.length,
-          sample_strikes: strikes.first(5)
-        }
-      else
-        { error: "Unexpected response format" }
-      end
-    rescue StandardError => e
-      { error: e.message }
-    end
-  },
-
-  "get_market_quote" => {
-    tool: market_quote_tool,
-    callable: lambda do |symbol:, exchange_segment:|
-      puts "\n  [TOOL EXECUTION] get_market_quote called by Executor"
-      puts "    Args: symbol=#{symbol}, exchange_segment=#{exchange_segment}"
-      puts "    Note: This is called AFTER LLM decided to use this tool!"
-      result = DhanHQDataTools.get_market_quote(
-        symbol: symbol.to_s,
-        exchange_segment: exchange_segment.to_s
-      )
-      if result[:error]
-        { error: result[:error] }
-      else
-        quote = result[:result][:quote]
-        {
-          symbol: symbol,
-          last_price: quote[:last_price],
-          volume: quote[:volume],
-          ohlc: quote[:ohlc]
-        }
-      end
-    end
-  },
-
-  "get_live_ltp" => {
-    tool: live_ltp_tool,
-    callable: lambda do |symbol:, exchange_segment:|
-      puts "\n  [TOOL EXECUTION] get_live_ltp called by Executor"
-      puts "    Args: symbol=#{symbol}, exchange_segment=#{exchange_segment}"
-      puts "    Note: This is called AFTER LLM decided to use this tool!"
-      sleep(1.2) # Rate limiting
-      result = DhanHQDataTools.get_live_ltp(
-        symbol: symbol.to_s,
-        exchange_segment: exchange_segment.to_s
-      )
-      if result[:error]
-        { error: result[:error] }
-      else
-        {
-          symbol: symbol,
-          ltp: result[:result][:ltp]
-        }
-      end
-    end
-  }
-}
-
-puts "--- Step 1: Show what tools are available to LLM ---"
-puts "Tools defined:"
-puts "  - get_market_quote: Get market quote"
-puts "  - get_live_ltp: Get live price"
-puts "  - get_option_chain: Get option chain for indices (NIFTY, SENSEX, BANKNIFTY)"
-puts "\nThese tool DEFINITIONS are sent to LLM (not executed yet)\n"
-
-puts "--- Step 2: LLM receives query and DECIDES which tools to call ---"
-puts "User query: 'Get RELIANCE quote, NIFTY price, and SENSEX option chain'\n"
-puts "LLM will analyze this and decide to call:"
-puts "  1. get_market_quote(RELIANCE, NSE_EQ)"
-puts "  2. get_live_ltp(NIFTY, IDX_I)"
-puts "  3. get_option_chain(SENSEX, IDX_I)"
-puts "\nThis decision is made by the LLM, not by your code!\n"
-
-puts "--- Step 3: Executor sends request to LLM with tool definitions ---"
-puts "Sending to LLM via chat_raw() with tools parameter...\n"
-
-# Create executor
-executor = Ollama::Agent::Executor.new(
-  client,
-  tools: tools,
-  max_steps: 10
-)
-
-begin
-  result = executor.run(
-    system: "You are a market data assistant. Use the available tools to get market data. " \
-            "For option chains, you can get SENSEX options using get_option_chain with " \
-            "symbol='SENSEX' and exchange_segment='IDX_I'.",
-    user: "Get market quote for RELIANCE stock, check NIFTY's current price, and get SENSEX option chain"
-  )
-
-  puts "\n--- Step 4: Final result from LLM (after tool execution) ---"
-  puts "=" * 60
-  puts result
-  puts "=" * 60
-rescue Ollama::Error => e
-  puts "\n❌ Error: #{e.message}"
-rescue StandardError => e
-  puts "\n❌ Unexpected error: #{e.message}"
-end
-
-puts "\n--- Summary ---"
-puts "✅ This IS real tool calling:"
-puts "   - LLM decides which tools to call (not your code)"
-puts "   - LLM returns tool_calls in response"
-puts "   - Executor detects tool_calls and executes callables"
-puts "   - Tool results fed back to LLM automatically"
-puts "   - LLM generates final answer based on tool results"
-puts "\nThe callables are just implementations - the LLM decides WHEN to call them!"
-puts "\n=== DONE ===\n"

data/examples/dhanhq/utils/instrument_helper.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module DhanHQ
-  module Utils
-    # Helper utilities for working with DhanHQ instruments
-    class InstrumentHelper
-      def self.safe_attr(instrument, attr_name)
-        return nil unless instrument
-
-        instrument.respond_to?(attr_name) ? instrument.send(attr_name) : nil
-      rescue StandardError
-        nil
-      end
-
-      def self.extract_value(data, keys)
-        return nil unless data
-
-        keys.each do |key|
-          if data.is_a?(Hash)
-            return data[key] if data.key?(key)
-          elsif data.respond_to?(key)
-            return data.send(key)
-          end
-        end
-
-        return data if data.is_a?(Numeric) || data.is_a?(String)
-
-        nil
-      end
-    end
-  end
-end

data/examples/dhanhq/utils/parameter_cleaner.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module DhanHQ
-  module Utils
-    # Cleans parameters from LLM responses (removes comments, instructions, etc.)
-    class ParameterCleaner
-      MAX_KEY_LENGTH = 50
-
-      def self.clean(params)
-        return {} unless params.is_a?(Hash)
-
-        params.reject do |key, _value|
-          key_str = key.to_s
-          invalid_key?(key_str)
-        end
-      end
-
-      def self.invalid_key?(key_str)
-        key_str.start_with?(">") ||
-          key_str.start_with?("//") ||
-          key_str.include?("adjust") ||
-          key_str.length > MAX_KEY_LENGTH
-      end
-
-      private_class_method :invalid_key?
-    end
-  end
-end

data/examples/dhanhq/utils/parameter_normalizer.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module DhanHQ
-  module Utils
-    # Normalizes parameters from LLM responses (handles arrays, stringified JSON, etc.)
-    class ParameterNormalizer
-      STRING_FIELDS = %w[symbol exchange_segment].freeze
-
-      def self.normalize(params)
-        return {} unless params.is_a?(Hash)
-
-        params.each_with_object({}) do |(key, value), normalized|
-          normalized[key] = if STRING_FIELDS.include?(key.to_s)
-                              normalize_string_field(value)
-                            else
-                              value
-                            end
-        end
-      end
-
-      def self.normalize_string_field(value)
-        return value.to_s if value.nil?
-
-        if value.is_a?(Array) && !value.empty?
-          value.first.to_s
-        elsif value.is_a?(String) && value.strip.start_with?("[") && value.strip.end_with?("]")
-          parse_stringified_array(value)
-        else
-          value.to_s
-        end
-      end
-
-      def self.parse_stringified_array(value)
-        parsed = JSON.parse(value)
-        parsed.is_a?(Array) && !parsed.empty? ? parsed.first.to_s : value.to_s
-      rescue JSON::ParserError
-        value.to_s
-      end
-
-      private_class_method :normalize_string_field, :parse_stringified_array
-    end
-  end
-end

data/examples/dhanhq/utils/rate_limiter.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module DhanHQ
-  module Utils
-    # Rate limiter for DhanHQ MarketFeed APIs (1 request per second)
-    class RateLimiter
-      MARKETFEED_INTERVAL = 1.1 # 1 second + 0.1s buffer
-
-      @last_marketfeed_call = nil
-      @marketfeed_mutex = Mutex.new
-
-      def self.marketfeed
-        @marketfeed_mutex.synchronize do
-          if @last_marketfeed_call
-            elapsed = Time.now - @last_marketfeed_call
-            sleep(MARKETFEED_INTERVAL - elapsed) if elapsed < MARKETFEED_INTERVAL
-          end
-          @last_marketfeed_call = Time.now
-        end
-      end
-    end
-  end
-end

data/examples/dhanhq/utils/trading_parameter_normalizer.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module DhanHQ
-  module Utils
-    # Normalizes trading parameters from LLM responses
-    # Handles common issues like comma-separated numbers, string numbers, etc.
-    class TradingParameterNormalizer
-      NUMERIC_FIELDS = %w[price target_price stop_loss_price quantity trailing_jump].freeze
-
-      def self.normalize(params)
-        return {} unless params.is_a?(Hash)
-
-        params.each_with_object({}) do |(key, value), normalized|
-          key_str = key.to_s
-          normalized[key] = if NUMERIC_FIELDS.include?(key_str)
-                              normalize_numeric(value)
-                            elsif key_str == "security_id"
-                              normalize_security_id(value)
-                            else
-                              value
-                            end
-        end
-      end
-
-      def self.normalize_numeric(value)
-        return nil if value.nil?
-
-        # If already a number, return as-is (but validate it's reasonable)
-        return value if value.is_a?(Numeric)
-
-        # If string, clean and convert
-        return nil unless value.is_a?(String)
-
-        # Remove commas, spaces, currency symbols, and convert
-        cleaned = value.to_s.gsub(/[,\s$₹]/, "")
-        return nil if cleaned.empty?
-
-        # Try to convert to float (for prices) or integer (for quantity)
-        if cleaned.include?(".")
-          cleaned.to_f
-        else
-          cleaned.to_i
-        end
-      rescue StandardError
-        nil
-      end
-
-      # Validates if a price value seems reasonable (not obviously wrong)
-      def self.valid_price?(price, context_hint = nil)
-        return false if price.nil?
-
-        # If price is suspiciously low (< 10), it might be wrong
-        # But we can't be too strict since some stocks might legitimately be < 10
-        # Check if context hint suggests a higher price
-        if price.is_a?(Numeric) && price.positive? && price < 10 &&
-           context_hint.is_a?(Numeric) && context_hint > price * 100
-          return false # Likely wrong
-        end
-
-        true
-      end
-
-      def self.normalize_security_id(value)
-        return nil if value.nil?
-
-        value.to_s
-      end
-
-      private_class_method :normalize_numeric, :normalize_security_id, :valid_price?
-    end
-  end
-end