ollama-client 0.2.1 → 0.2.3

data/examples/dhanhq/dhanhq_agent.rb

@@ -59,6 +59,139 @@ module DhanHQ
   end
 end
 
+def price_range_stats(price_ranges)
+  return nil unless price_ranges.is_a?(Array) && price_ranges.any?
+
+  {
+    min: price_ranges.min.round(2),
+    max: price_ranges.max.round(2),
+    avg: (price_ranges.sum / price_ranges.length).round(2),
+    count: price_ranges.length
+  }
+end
+
+def build_expired_options_summary(stats)
+  {
+    data_points: stats[:data_points] || 0,
+    avg_volume: stats[:avg_volume]&.round(2),
+    avg_open_interest: stats[:avg_open_interest]&.round(2),
+    avg_implied_volatility: stats[:avg_implied_volatility]&.round(4),
+    price_range_stats: price_range_stats(stats[:price_ranges]),
+    has_ohlc: stats[:has_ohlc],
+    has_volume: stats[:has_volume],
+    has_open_interest: stats[:has_open_interest],
+    has_implied_volatility: stats[:has_implied_volatility]
+  }
+end
+
+def build_option_chain_summary(chain_result)
+  chain = chain_result[:result][:chain]
+  underlying_price = chain_result[:result][:underlying_last_price]
+
+  unless chain.is_a?(Hash)
+    return [{ expiry: chain_result[:result][:expiry], chain_type: chain.class },
+            underlying_price]
+  end
+
+  strike_prices = chain.keys.sort_by(&:to_f)
+  first_strike_data = strike_prices.any? ? chain[strike_prices.first] : nil
+  atm_strike = select_atm_strike(strike_prices, underlying_price)
+  atm_data = atm_strike ? chain[atm_strike] : nil
+  sample_greeks = build_sample_greeks(atm_data, atm_strike)
+
+  summary = {
+    expiry: chain_result[:result][:expiry],
+    underlying_last_price: underlying_price,
+    strikes_count: strike_prices.length,
+    has_call_options: option_type_present?(first_strike_data, "ce"),
+    has_put_options: option_type_present?(first_strike_data, "pe"),
+    has_greeks: sample_greeks.any?,
+    strike_range: strike_range_summary(strike_prices),
+    sample_greeks: sample_greeks.any? ? sample_greeks : nil
+  }
+
+  [summary, underlying_price]
+end
+
+def select_atm_strike(strike_prices, underlying_price)
+  return strike_prices.first unless underlying_price && strike_prices.any?
+
+  strike_prices.min_by { |strike| (strike.to_f - underlying_price).abs }
+end
+
+def option_type_present?(strike_data, key)
+  strike_data.is_a?(Hash) && (strike_data.key?(key) || strike_data.key?(key.to_sym))
+end
+
+def strike_range_summary(strike_prices)
+  return nil if strike_prices.empty?
+
+  {
+    min: strike_prices.first,
+    max: strike_prices.last,
+    sample_strikes: strike_prices.first(5)
+  }
+end
+
+def build_sample_greeks(atm_data, atm_strike)
+  return {} unless atm_data.is_a?(Hash)
+
+  sample = {}
+  call_data = atm_data["ce"] || atm_data[:ce]
+  put_data = atm_data["pe"] || atm_data[:pe]
+
+  call_greeks = extract_greeks(call_data)
+  sample[:call] = greeks_summary(call_greeks, call_data, atm_strike) if call_greeks
+
+  put_greeks = extract_greeks(put_data)
+  sample[:put] = greeks_summary(put_greeks, put_data, atm_strike) if put_greeks
+
+  sample
+end
+
+def extract_greeks(option_data)
+  return nil unless option_data.is_a?(Hash)
+  return nil unless option_data.key?("greeks") || option_data.key?(:greeks)
+
+  option_data["greeks"] || option_data[:greeks]
+end
+
+def greeks_summary(greeks, option_data, atm_strike)
+  {
+    strike: atm_strike,
+    delta: greeks["delta"] || greeks[:delta],
+    theta: greeks["theta"] || greeks[:theta],
+    gamma: greeks["gamma"] || greeks[:gamma],
+    vega: greeks["vega"] || greeks[:vega],
+    iv: option_data["implied_volatility"] || option_data[:implied_volatility],
+    oi: option_data["oi"] || option_data[:oi],
+    last_price: option_data["last_price"] || option_data[:last_price]
+  }
+end
+
+def format_score_breakdown(details)
+  "Trend=#{details[:trend]}, RSI=#{details[:rsi]}, MACD=#{details[:macd]}, " \
+    "Structure=#{details[:structure]}, Patterns=#{details[:patterns]}"
+end
+
+def format_option_setup_details(setup)
+  iv = setup[:iv]&.round(2) || "N/A"
+  oi = setup[:oi] || "N/A"
+  volume = setup[:volume] || "N/A"
+  "IV: #{iv}% | OI: #{oi} | Volume: #{volume}"
+end
+
+def handle_option_chain_result(chain_result)
+  if chain_result[:result] && chain_result[:result][:chain]
+    chain_summary, underlying_price = build_option_chain_summary(chain_result)
+    puts "   ✅ Option chain retrieved for expiry: #{chain_result[:result][:expiry]}"
+    puts "   📊 Underlying LTP: #{underlying_price}" if underlying_price
+    puts "   📊 Chain summary: #{JSON.pretty_generate(chain_summary)}"
+  elsif chain_result[:error]
+    puts "   ⚠️  Could not retrieve option chain data: #{chain_result[:error]}"
+  end
+end
+
 # Main execution
 if __FILE__ == $PROGRAM_NAME
   # Configure DhanHQ
@@ -267,7 +400,7 @@ if __FILE__ == $PROGRAM_NAME
       puts "   ✅ Historical data retrieved"
       puts "   📊 Type: #{result[:type]}"
       puts "   📊 Records: #{result[:result][:count]}"
-      if result[:result][:count] == 0
+      if result[:result][:count].zero?
         puts "   ⚠️  No data found for date range #{from_date} to #{to_date}"
         puts "      (This may be normal if market was closed or data unavailable)"
       end
@@ -300,26 +433,7 @@ if __FILE__ == $PROGRAM_NAME
       puts "   📊 Expiry: #{result[:result][:expiry_date]}"
       if result[:result][:summary_stats]
         stats = result[:result][:summary_stats]
-        concise_summary = {
-          data_points: stats[:data_points] || 0,
-          avg_volume: stats[:avg_volume]&.round(2),
-          avg_open_interest: stats[:avg_open_interest]&.round(2),
-          avg_implied_volatility: stats[:avg_implied_volatility]&.round(4),
-          price_range_stats: if stats[:price_ranges]&.is_a?(Array) && !stats[:price_ranges].empty?
-                               {
-                                 min: stats[:price_ranges].min.round(2),
-                                 max: stats[:price_ranges].max.round(2),
-                                 avg: (stats[:price_ranges].sum / stats[:price_ranges].length).round(2),
-                                 count: stats[:price_ranges].length
-                               }
-                             else
-                               nil
-                             end,
-          has_ohlc: stats[:has_ohlc],
-          has_volume: stats[:has_volume],
-          has_open_interest: stats[:has_open_interest],
-          has_implied_volatility: stats[:has_implied_volatility]
-        }
+        concise_summary = build_expired_options_summary(stats)
         puts "   📊 Data summary: #{JSON.pretty_generate(concise_summary)}"
       else
         puts "   📊 Data available but summary stats not found"
@@ -355,82 +469,7 @@ if __FILE__ == $PROGRAM_NAME
           exchange_segment: "IDX_I",
           expiry: next_expiry
         )
-        if chain_result[:result] && chain_result[:result][:chain]
-          chain = chain_result[:result][:chain]
-          underlying_price = chain_result[:result][:underlying_last_price]
-
-          chain_summary = if chain.is_a?(Hash)
-                            strike_prices = chain.keys.sort_by { |k| k.to_f }
-                            first_strike_data = chain[strike_prices.first] unless strike_prices.empty?
-
-                            atm_strike = if underlying_price && !strike_prices.empty?
-                                           strike_prices.min_by { |s| (s.to_f - underlying_price).abs }
-                                         else
-                                           strike_prices.first
-                                         end
-                            atm_data = chain[atm_strike] if atm_strike
-
-                            sample_greeks = {}
-                            if atm_data.is_a?(Hash)
-                              ce_data = atm_data["ce"] || atm_data[:ce]
-                              pe_data = atm_data["pe"] || atm_data[:pe]
-
-                              if ce_data.is_a?(Hash) && (ce_data.key?("greeks") || ce_data.key?(:greeks))
-                                ce_greeks = ce_data["greeks"] || ce_data[:greeks]
-                                sample_greeks[:call] = {
-                                  strike: atm_strike,
-                                  delta: ce_greeks["delta"] || ce_greeks[:delta],
-                                  theta: ce_greeks["theta"] || ce_greeks[:theta],
-                                  gamma: ce_greeks["gamma"] || ce_greeks[:gamma],
-                                  vega: ce_greeks["vega"] || ce_greeks[:vega],
-                                  iv: ce_data["implied_volatility"] || ce_data[:implied_volatility],
-                                  oi: ce_data["oi"] || ce_data[:oi],
-                                  last_price: ce_data["last_price"] || ce_data[:last_price]
-                                }
-                              end
-
-                              if pe_data.is_a?(Hash) && (pe_data.key?("greeks") || pe_data.key?(:greeks))
-                                pe_greeks = pe_data["greeks"] || pe_data[:greeks]
-                                sample_greeks[:put] = {
-                                  strike: atm_strike,
-                                  delta: pe_greeks["delta"] || pe_greeks[:delta],
-                                  theta: pe_greeks["theta"] || pe_greeks[:theta],
-                                  gamma: pe_greeks["gamma"] || pe_greeks[:gamma],
-                                  vega: pe_greeks["vega"] || pe_greeks[:vega],
-                                  iv: pe_data["implied_volatility"] || pe_data[:implied_volatility],
-                                  oi: pe_data["oi"] || pe_data[:oi],
-                                  last_price: pe_data["last_price"] || pe_data[:last_price]
-                                }
-                              end
-                            end
-
-                            {
-                              expiry: chain_result[:result][:expiry],
-                              underlying_last_price: underlying_price,
-                              strikes_count: strike_prices.length,
-                              has_call_options: first_strike_data.is_a?(Hash) && (first_strike_data.key?("ce") || first_strike_data.key?(:ce)),
-                              has_put_options: first_strike_data.is_a?(Hash) && (first_strike_data.key?("pe") || first_strike_data.key?(:pe)),
-                              has_greeks: !sample_greeks.empty?,
-                              strike_range: if strike_prices.empty?
-                                              nil
-                                            else
-                                              {
-                                                min: strike_prices.first,
-                                                max: strike_prices.last,
-                                                sample_strikes: strike_prices.first(5)
-                                              }
-                                            end,
-                              sample_greeks: sample_greeks.empty? ? nil : sample_greeks
-                            }
-                          else
-                            { expiry: chain_result[:result][:expiry], chain_type: chain.class }
-                          end
-          puts "   ✅ Option chain retrieved for expiry: #{chain_result[:result][:expiry]}"
-          puts "   📊 Underlying LTP: #{underlying_price}" if underlying_price
-          puts "   📊 Chain summary: #{JSON.pretty_generate(chain_summary)}"
-        elsif chain_result[:error]
-          puts "   ⚠️  Could not retrieve option chain data: #{chain_result[:error]}"
-        end
+        handle_option_chain_result(chain_result)
       end
     elsif expiry_list_result[:error]
       puts "   ⚠️  #{expiry_list_result[:error]}"
@@ -573,7 +612,7 @@ if __FILE__ == $PROGRAM_NAME
         puts "      📈 #{candidate[:symbol]}: Score #{candidate[:score]}/100"
         if candidate[:score_details]
           details = candidate[:score_details]
-          puts "         Breakdown: Trend=#{details[:trend]}, RSI=#{details[:rsi]}, MACD=#{details[:macd]}, Structure=#{details[:structure]}, Patterns=#{details[:patterns]}"
+          puts "         Breakdown: #{format_score_breakdown(details)}"
         end
         trend = candidate[:analysis][:trend]
         puts "         Trend: #{trend[:trend]} (#{trend[:strength]}% strength)"
@@ -605,7 +644,7 @@ if __FILE__ == $PROGRAM_NAME
       puts "   ✅ Found #{options_setups[:setups].length} options setups:"
       options_setups[:setups].each do |setup|
         puts "      📊 #{setup[:type].to_s.upcase} @ #{setup[:strike]}"
-        puts "         IV: #{setup[:iv]&.round(2) || 'N/A'}% | OI: #{setup[:oi] || 'N/A'} | Volume: #{setup[:volume] || 'N/A'}"
+        puts "         #{format_option_setup_details(setup)}"
         puts "         Score: #{setup[:score]}/100 | Recommendation: #{setup[:recommendation]}"
       end
     else
@@ -617,6 +656,163 @@ if __FILE__ == $PROGRAM_NAME
     puts "   #{e.backtrace.first(3).join("\n   ")}" if e.backtrace
   end
 
+  puts
+  puts "=" * 60
+  puts "TOOL CALLING EXAMPLE (Using Executor + Structured Tool Classes)"
+  puts "=" * 60
+  puts
+
+  # ============================================================
+  # TOOL CALLING WITH EXECUTOR
+  # ============================================================
+  puts "Example: Agentic Tool Calling with DhanHQ Tools"
+  puts "─" * 60
+  puts "This demonstrates the new tool calling pattern using:"
+  puts "  - Structured Tool classes (type-safe schemas)"
+  puts "  - Executor (automatic tool execution loop)"
+  puts "  - chat_raw() internally (via Executor)"
+  puts
+
+  # Define DhanHQ tools using structured Tool classes
+  market_quote_tool = Ollama::Tool.new(
+    type: "function",
+    function: Ollama::Tool::Function.new(
+      name: "get_market_quote",
+      description: "Get market quote for a symbol. Returns OHLC, depth, volume, and other market data. " \
+                   "Finds instrument automatically using exchange_segment and symbol.",
+      parameters: Ollama::Tool::Function::Parameters.new(
+        type: "object",
+        properties: {
+          symbol: Ollama::Tool::Function::Parameters::Property.new(
+            type: "string",
+            description: "Stock or index symbol (e.g., RELIANCE, NIFTY)"
+          ),
+          exchange_segment: Ollama::Tool::Function::Parameters::Property.new(
+            type: "string",
+            description: "Exchange segment",
+            enum: %w[NSE_EQ NSE_FNO BSE_EQ BSE_FNO 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 (LTP) for a symbol. Fast API for current price. " \
+                   "Finds instrument automatically using exchange_segment and symbol.",
+      parameters: Ollama::Tool::Function::Parameters.new(
+        type: "object",
+        properties: {
+          symbol: Ollama::Tool::Function::Parameters::Property.new(
+            type: "string",
+            description: "Stock or index symbol"
+          ),
+          exchange_segment: Ollama::Tool::Function::Parameters::Property.new(
+            type: "string",
+            description: "Exchange segment",
+            enum: %w[NSE_EQ NSE_FNO BSE_EQ BSE_FNO IDX_I]
+          )
+        },
+        required: %w[symbol exchange_segment]
+      )
+    )
+  )
+
+  # Define tools with structured Tool classes and callables
+  tools = {
+    "get_market_quote" => {
+      tool: market_quote_tool,
+      callable: lambda do |symbol:, exchange_segment:|
+        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,
+            exchange_segment: exchange_segment,
+            last_price: quote[:last_price],
+            volume: quote[:volume],
+            ohlc: quote[:ohlc],
+            change_percent: quote[:net_change]
+          }
+        end
+      rescue StandardError => e
+        { error: e.message }
+      end
+    },
+
+    "get_live_ltp" => {
+      tool: live_ltp_tool,
+      callable: lambda do |symbol:, exchange_segment:|
+        result = DhanHQDataTools.get_live_ltp(
+          symbol: symbol.to_s,
+          exchange_segment: exchange_segment.to_s
+        )
+
+        if result[:error]
+          { error: result[:error] }
+        else
+          {
+            symbol: symbol,
+            exchange_segment: exchange_segment,
+            ltp: result[:result][:ltp],
+            timestamp: result[:result][:timestamp]
+          }
+        end
+      rescue StandardError => e
+        { error: e.message }
+      end
+    }
+  }
+
+  # Create executor with tools
+  # Create client with same configuration as other examples
+  executor_config = Ollama::Config.new
+  executor_config.model = ENV.fetch("OLLAMA_MODEL", "llama3.1:8b")
+  executor_config.temperature = 0.2
+  executor_config.timeout = 60
+  executor_client = Ollama::Client.new(config: executor_config)
+
+  executor = Ollama::Agent::Executor.new(
+    executor_client,
+    tools: tools,
+    max_steps: 10
+  )
+
+  begin
+    puts "🔄 Starting agentic tool-calling loop..."
+    puts "User query: Get market quote for RELIANCE and also check NIFTY's current price"
+    puts
+
+    result = executor.run(
+      system: "You are a market data assistant. Use the available tools to get market data. " \
+              "You can call multiple tools in sequence. When you have the data, summarize it for the user.",
+      user: "Get market quote for RELIANCE stock and also check NIFTY's current price"
+    )
+
+    puts
+    puts "=" * 60
+    puts "Tool Calling Result:"
+    puts "=" * 60
+    puts result
+    puts
+  rescue Ollama::Error => e
+    puts "❌ Error: #{e.message}"
+    puts e.backtrace.first(5).join("\n") if e.backtrace
+  rescue StandardError => e
+    puts "❌ Unexpected error: #{e.message}"
+    puts e.backtrace.first(3).join("\n") if e.backtrace
+  end
+
   puts
   puts "=" * 60
   puts "DhanHQ Agent Summary:"
@@ -628,5 +824,6 @@ if __FILE__ == $PROGRAM_NAME
   puts "  ✅ Technical Analysis: Trend analysis, SMC concepts, Pattern recognition, Indicators (RSI, MACD, MA, etc.)"
   puts "  ✅ Scanners: Swing trading scanner, Intraday options scanner"
   puts "  ✅ Analysis Agents: Technical analysis agent with LLM interpretation"
+  puts "  ✅ Tool Calling: Executor with structured Tool classes (NEW!)"
   puts "=" * 60
 end

data/examples/dhanhq/indicators/technical_indicators.rb

@@ -35,8 +35,8 @@ module DhanHQ
 
         prices.each_cons(2) do |prev, curr|
           change = curr - prev
-          gains << (change > 0 ? change : 0)
-          losses << (change < 0 ? -change : 0)
+          gains << [change, 0].max
+          losses << (change.negative? ? -change : 0)
         end
 
         rsi_values = []
@@ -81,7 +81,7 @@ module DhanHQ
         sma_values = sma(prices, period)
         bands = { upper: [], middle: sma_values, lower: [] }
 
-        prices.each_cons(period).each_with_index do |window, idx|
+        prices.each_cons(period).with_index do |window, idx|
           mean = sma_values[idx]
           variance = window.map { |p| (p - mean)**2 }.sum / period
           std = Math.sqrt(variance)
@@ -147,8 +147,6 @@ module DhanHQ
         { support: support_levels.uniq { |s| s[:price] }, resistance: resistance_levels.uniq { |r| r[:price] } }
       end
 
-      private
-
       def self.calculate_rsi_value(avg_gain, avg_loss)
         return 100 if avg_loss.zero?