ollama-client 0.2.1 → 0.2.3

data/examples/dhanhq/test_tool_calling_verbose.rb

@@ -0,0 +1,251 @@
+#!/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/trading_parameter_normalizer.rb

@@ -26,9 +26,7 @@ module DhanHQ
         return nil if value.nil?
 
         # If already a number, return as-is (but validate it's reasonable)
-        if value.is_a?(Numeric)
-          return value
-        end
+        return value if value.is_a?(Numeric)
 
         # If string, clean and convert
         return nil unless value.is_a?(String)
@@ -38,28 +36,25 @@ module DhanHQ
         return nil if cleaned.empty?
 
         # Try to convert to float (for prices) or integer (for quantity)
-        result = if cleaned.include?(".")
-                   cleaned.to_f
-                 else
-                   cleaned.to_i
-                 end
-
-        result
+        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.validate_price(price, context_hint = nil)
+      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
-        if price.is_a?(Numeric) && price > 0 && price < 10
-          # Check if context hint suggests a higher price
-          if context_hint && context_hint.is_a?(Numeric) && context_hint > price * 100
-            return false # Likely wrong
-          end
+        # 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
@@ -71,7 +66,7 @@ module DhanHQ
         value.to_s
       end
 
-      private_class_method :normalize_numeric, :normalize_security_id
+      private_class_method :normalize_numeric, :normalize_security_id, :valid_price?
     end
   end
 end

data/examples/dhanhq_agent.rb

@@ -76,7 +76,7 @@ class DataAgent
           "type" => "number",
           "minimum" => 0,
           "maximum" => 1,
-          "description" => "Confidence in this decision"
+          "description" => "Confidence in this decision (0.0 to 1.0, where 1.0 is 100% confident)"
         },
         "parameters" => {
           "type" => "object",
@@ -304,7 +304,7 @@ class TradingAgent
           "type" => "number",
           "minimum" => 0,
           "maximum" => 1,
-          "description" => "Confidence in this decision"
+          "description" => "Confidence in this decision (0.0 to 1.0, where 1.0 is 100% confident)"
         },
         "parameters" => {
           "type" => "object",
@@ -443,6 +443,139 @@ class TradingAgent
   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 (must be done before using DhanHQ models)
@@ -529,16 +662,26 @@ if __FILE__ == $PROGRAM_NAME
     puts "  ⚠️  RELIANCE data error: #{e.message}"
   end
 
-  # NOTE: Positions and holdings are not part of the 6 Data APIs
+  # NOTE: Positions and holdings are not part of the 6 Data APIs, but available via DhanHQ gem
   begin
-    positions_result = { action: "check_positions", result: { positions: [], count: 0 },
-                         note: "Positions API not available in Data Tools" }
-    if positions_result[:result]
-      market_data[:positions] = positions_result[:result][:positions] || []
-      puts "  ✅ Positions: #{positions_result[:result][:count] || 0} active"
-    else
-      puts "  ✅ Positions: 0 active (Positions API not in Data Tools)"
-      market_data[:positions] = []
+    positions_list = DhanHQ::Models::Position.all
+    positions_data = positions_list.map do |pos|
+      {
+        trading_symbol: pos.trading_symbol,
+        quantity: pos.net_qty,
+        average_price: pos.buy_avg,
+        exchange_segment: pos.exchange_segment,
+        security_id: pos.security_id,
+        pnl: pos.realized_profit
+      }
+    end
+    market_data[:positions] = positions_data
+    puts "  ✅ Positions: #{positions_data.length} active"
+
+    if positions_data.any?
+      positions_data.each do |pos|
+        puts "     - #{pos[:trading_symbol]}: Qty #{pos[:quantity]} @ ₹#{pos[:average_price]}"
+      end
     end
   rescue StandardError => e
     puts "  ⚠️  Positions error: #{e.message}"
@@ -661,7 +804,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
@@ -698,27 +841,7 @@ if __FILE__ == $PROGRAM_NAME
       # Show concise summary of expired options data instead of full data (can be very large)
       if result[:result][:summary_stats]
         stats = result[:result][:summary_stats]
-        # Create a concise summary without the huge price_ranges array
-        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"
@@ -739,8 +862,8 @@ if __FILE__ == $PROGRAM_NAME
   begin
     # NOTE: Options symbols may need different format
     # Try with NIFTY which typically has options
-    # First, get the list of available expiries
-    expiry_list_result = DhanHQDataTools.get_option_chain(
+    # First, get the list of available expiries using get_expiry_list
+    expiry_list_result = DhanHQDataTools.get_expiry_list(
       symbol: "NIFTY", # NIFTY typically has options, RELIANCE might not
       exchange_segment: "IDX_I"
     )
@@ -759,87 +882,7 @@ if __FILE__ == $PROGRAM_NAME
           exchange_segment: "IDX_I", # Use IDX_I for index options underlying
           expiry: next_expiry
         )
-        if chain_result[:result] && chain_result[:result][:chain]
-          chain = chain_result[:result][:chain]
-          underlying_price = chain_result[:result][:underlying_last_price]
-
-          # Option chain structure: chain[:oc] is a hash with strike prices as string keys
-          # Each strike contains "ce" (call) and "pe" (put) data with Greeks, IV, OI, etc.
-          chain_summary = if chain.is_a?(Hash)
-                            # Strike prices are string keys (e.g., "25000.000000")
-                            strike_prices = chain.keys.sort_by { |k| k.to_f }
-                            first_strike_data = chain[strike_prices.first] unless strike_prices.empty?
-
-                            # Find ATM or nearest strike to underlying price for sample Greeks
-                            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
-
-                            # Extract Greeks from ATM strike if available
-                            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]}"