ollama-client 0.2.1 → 0.2.3

data/examples/dhanhq/scanners/swing_scanner.rb

@@ -49,16 +49,14 @@ module DhanHQ
           puts "   📋 Rejected candidates:"
           rejected.each do |r|
             puts "      ❌ #{r[:symbol]}: Score #{r[:score]}/100 - #{r[:reason]}"
-            if r[:details]
-              puts "         Breakdown: Trend=#{r[:details][:trend]}, RSI=#{r[:details][:rsi]}, MACD=#{r[:details][:macd]}, Structure=#{r[:details][:structure]}, Patterns=#{r[:details][:patterns]}"
-            end
+            puts "         Breakdown: #{format_score_breakdown(r[:details])}" if r[:details]
           end
         end
 
         candidates.sort_by { |c| -c[:score] }
       end
 
-      def scan_by_criteria(criteria = {})
+      def scan_by_criteria(_criteria = {})
         # This would typically fetch a list of symbols from an API
         # For now, return empty - would need symbol list source
         []
@@ -99,45 +97,15 @@ module DhanHQ
       end
 
       def calculate_swing_score_details(analysis)
-        return { trend: 0, rsi: 0, macd: 0, structure: 0, patterns: 0 } if analysis.nil? || analysis.empty?
+        return empty_score_details if analysis.nil? || analysis.empty?
 
-        details = { trend: 0, rsi: 0, macd: 0, structure: 0, patterns: 0 }
-
-        # Trend strength (0-30 points)
-        trend = analysis[:trend]
-        details[:trend] = (trend[:strength] || 0).clamp(0, 30) if trend && trend[:trend] == :uptrend
-
-        # RSI (0-20 points) - prefer 40-60 for swing entries
-        rsi = analysis[:indicators]&.dig(:rsi)
-        if rsi
-          if rsi.between?(40, 60)
-            details[:rsi] = 20
-          elsif rsi.between?(30, 70)
-            details[:rsi] = 10
-          end
-        end
-
-        # MACD (0-20 points) - bullish crossover
-        macd = analysis[:indicators]&.dig(:macd)
-        signal = analysis[:indicators]&.dig(:macd_signal)
-        if macd && signal && macd > signal
-          details[:macd] = 20
-        elsif macd && signal && macd > signal * 0.9
-          details[:macd] = 10
-        end
-
-        # Structure break (0-15 points)
-        structure_break = analysis[:structure_break]
-        if structure_break && structure_break[:broken] && structure_break[:direction] == :bullish_break
-          details[:structure] = 15
-        end
-
-        # Patterns (0-15 points)
-        patterns = analysis[:patterns]&.dig(:candlestick) || []
-        bullish_patterns = patterns.count { |p| p.is_a?(Hash) && p[:type].to_s.include?("bullish") }
-        details[:patterns] = [bullish_patterns * 5, 15].min
-
-        details
+        {
+          trend: trend_points(analysis),
+          rsi: rsi_points(analysis),
+          macd: macd_points(analysis),
+          structure: structure_points(analysis),
+          patterns: pattern_points(analysis)
+        }
       end
 
       def interpret_for_swing(analysis)
@@ -149,7 +117,7 @@ module DhanHQ
 
         if trend == :uptrend && rsi && rsi < 70 && structure_break && structure_break[:broken]
           "Strong swing candidate - uptrend with bullish structure break"
-        elsif trend == :uptrend && rsi && rsi.between?(40, 60)
+        elsif trend == :uptrend && rsi&.between?(40, 60)
           "Good swing candidate - healthy uptrend, RSI in good zone"
         else
           "Moderate candidate - review individual factors"
@@ -159,54 +127,120 @@ module DhanHQ
       def convert_to_ohlc(historical_data)
         return [] unless historical_data.is_a?(Hash)
 
-        # Navigate to the actual data: result -> result -> data
+        data = extract_data_payload(historical_data)
+        return [] unless data
+
+        return ohlc_from_hash(data) if data.is_a?(Hash)
+        return ohlc_from_array(data) if data.is_a?(Array)
+
+        []
+      end
+
+      def format_score_breakdown(details)
+        "Trend=#{details[:trend]}, RSI=#{details[:rsi]}, MACD=#{details[:macd]}, " \
+          "Structure=#{details[:structure]}, Patterns=#{details[:patterns]}"
+      end
+
+      def empty_score_details
+        { trend: 0, rsi: 0, macd: 0, structure: 0, patterns: 0 }
+      end
+
+      def trend_points(analysis)
+        trend = analysis[:trend]
+        return 0 unless trend && trend[:trend] == :uptrend
+
+        (trend[:strength] || 0).clamp(0, 30)
+      end
+
+      def rsi_points(analysis)
+        rsi = analysis[:indicators]&.dig(:rsi)
+        return 0 unless rsi
+        return 20 if rsi.between?(40, 60)
+        return 10 if rsi.between?(30, 70)
+
+        0
+      end
+
+      def macd_points(analysis)
+        macd = analysis[:indicators]&.dig(:macd)
+        signal = analysis[:indicators]&.dig(:macd_signal)
+        return 0 unless macd && signal
+
+        return 20 if macd > signal
+        return 10 if macd > signal * 0.9
+
+        0
+      end
+
+      def structure_points(analysis)
+        structure_break = analysis[:structure_break]
+        return 0 unless structure_break && structure_break[:broken]
+        return 0 unless structure_break[:direction] == :bullish_break
+
+        15
+      end
+
+      def pattern_points(analysis)
+        patterns = analysis[:patterns]&.dig(:candlestick) || []
+        bullish_patterns = patterns.count { |pattern| pattern.is_a?(Hash) && pattern[:type].to_s.include?("bullish") }
+        [bullish_patterns * 5, 15].min
+      end
+
+      def extract_data_payload(historical_data)
         outer_result = historical_data[:result] || historical_data["result"]
-        return [] unless outer_result.is_a?(Hash)
+        return nil unless outer_result.is_a?(Hash)
 
-        data = outer_result[:data] || outer_result["data"]
-        return [] unless data
+        outer_result[:data] || outer_result["data"]
+      end
 
-        # Handle DhanHQ format: {open: [...], high: [...], low: [...], close: [...], volume: [...]}
-        if data.is_a?(Hash)
-          opens = data[:open] || data["open"] || []
-          highs = data[:high] || data["high"] || []
-          lows = data[:low] || data["low"] || []
-          closes = data[:close] || data["close"] || []
-          volumes = data[:volume] || data["volume"] || []
-
-          return [] if closes.empty?
-
-          # Convert parallel arrays to array of hashes
-          max_length = [opens.length, highs.length, lows.length, closes.length].max
-          ohlc_data = []
-
-          (0...max_length).each do |i|
-            ohlc_data << {
-              open: opens[i],
-              high: highs[i],
-              low: lows[i],
-              close: closes[i],
-              volume: volumes[i] || 0
-            }
-          end
+      def ohlc_from_hash(data)
+        series = extract_series(data)
+        return [] if series[:closes].empty?
 
-          return ohlc_data
-        end
+        max_length = series_lengths(series).max
+        build_ohlc_rows(series, max_length)
+      end
 
-        # Handle array format: [{open, high, low, close, volume}, ...]
-        if data.is_a?(Array)
-          return data.map do |bar|
-            {
-              open: bar["open"] || bar[:open],
-              high: bar["high"] || bar[:high],
-              low: bar["low"] || bar[:low],
-              close: bar["close"] || bar[:close],
-              volume: bar["volume"] || bar[:volume]
-            }
-          end.compact
+      def extract_series(data)
+        {
+          opens: data[:open] || data["open"] || [],
+          highs: data[:high] || data["high"] || [],
+          lows: data[:low] || data["low"] || [],
+          closes: data[:close] || data["close"] || [],
+          volumes: data[:volume] || data["volume"] || []
+        }
+      end
+
+      def series_lengths(series)
+        [series[:opens].length, series[:highs].length, series[:lows].length, series[:closes].length]
+      end
+
+      def build_ohlc_rows(series, max_length)
+        (0...max_length).map do |index|
+          {
+            open: series[:opens][index],
+            high: series[:highs][index],
+            low: series[:lows][index],
+            close: series[:closes][index],
+            volume: series[:volumes][index] || 0
+          }
         end
+      end
 
-        []
+      def ohlc_from_array(data)
+        data.filter_map { |bar| normalize_bar(bar) }
+      end
+
+      def normalize_bar(bar)
+        return nil unless bar.is_a?(Hash)
+
+        {
+          open: bar["open"] || bar[:open],
+          high: bar["high"] || bar[:high],
+          low: bar["low"] || bar[:low],
+          close: bar["close"] || bar[:close],
+          volume: bar["volume"] || bar[:volume]
+        }
       end
     end
   end

data/examples/dhanhq/schemas/agent_schemas.rb

@@ -21,7 +21,7 @@ module DhanHQ
             "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",
@@ -47,7 +47,7 @@ module DhanHQ
             "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",

data/examples/dhanhq/services/data_service.rb

@@ -3,10 +3,6 @@
 require_relative "base_service"
 require_relative "../../dhanhq_tools"
 
-# Keep backward compatibility - these are still used by the service
-DhanHQDataTools = DhanHQDataTools unless defined?(DhanHQDataTools)
-DhanHQTradingTools = DhanHQTradingTools unless defined?(DhanHQTradingTools)
-
 module DhanHQ
   module Services
     # Service for executing data retrieval actions
@@ -85,9 +81,11 @@ module DhanHQ
       end
 
       def execute_expired_options_data(params)
-        return error_response("get_expired_options_data",
-                              "Either symbol or security_id, and expiry_date are required",
-                              params) if missing_expired_options_params?(params)
+        if missing_expired_options_params?(params)
+          return error_response("get_expired_options_data",
+                                "Either symbol or security_id, and expiry_date are required",
+                                params)
+        end
 
         DhanHQDataTools.get_expired_options_data(
           symbol: params["symbol"],

data/examples/dhanhq/services/trading_service.rb

@@ -3,9 +3,6 @@
 require_relative "base_service"
 require_relative "../../dhanhq_tools"
 
-# Keep backward compatibility
-DhanHQTradingTools = DhanHQTradingTools unless defined?(DhanHQTradingTools)
-
 module DhanHQ
   module Services
     # Service for executing trading order actions

data/examples/dhanhq/technical_analysis_agentic_runner.rb

@@ -78,104 +78,187 @@ puts
 # Initialize agent
 agent = DhanHQ::Agent.new
 
-# Define tools as callable functions
-tools = {
-  "swing_scan" => lambda do |args|
-    symbol = args["symbol"] || args[:symbol]
-    exchange_segment = args["exchange_segment"] || args[:exchange_segment] || "NSE_EQ"
-    min_score = args["min_score"] || args[:min_score] || 40
-    verbose = args["verbose"] || args[:verbose] || false
-
-    unless symbol
-      return { error: "symbol is required for swing_scan" }
-    end
-
-    # CRITICAL: Only allow equity stocks, not indices
-    if %w[NIFTY SENSEX BANKNIFTY].include?(symbol.to_s.upcase)
-      return { error: "#{symbol} is an index, not a stock. Use options_scan for indices." }
-    end
-
-    begin
-      candidates = agent.swing_scanner.scan_symbols(
-        [symbol.to_s],
-        exchange_segment: exchange_segment.to_s,
-        min_score: min_score.to_i,
-        verbose: verbose
-      )
-
-      {
-        symbol: symbol,
-        exchange_segment: exchange_segment,
-        candidates_found: candidates.length,
-        candidates: candidates.map do |c|
-          {
-            symbol: c[:symbol],
-            score: c[:score],
-            trend: c[:analysis][:trend][:trend],
-            recommendation: c[:recommendation]
-          }
-        end
-      }
-    rescue StandardError => e
-      { error: e.message, backtrace: e.backtrace.first(3) }
-    end
-  end,
+# Define tools using structured Tool classes for better type safety and LLM understanding
+# This provides explicit schemas with descriptions, types, and enums
+
+# Swing Scan Tool - Structured definition
+swing_scan_tool = Ollama::Tool.new(
+  type: "function",
+  function: Ollama::Tool::Function.new(
+    name: "swing_scan",
+    description: "Scans for swing trading opportunities in EQUITY STOCKS only. " \
+                 "Use for stocks like RELIANCE, TCS, INFY, HDFC. " \
+                 "Do NOT use for indices (NIFTY, SENSEX, BANKNIFTY).",
+    parameters: Ollama::Tool::Function::Parameters.new(
+      type: "object",
+      properties: {
+        symbol: Ollama::Tool::Function::Parameters::Property.new(
+          type: "string",
+          description: "Stock symbol to scan (e.g., RELIANCE, TCS, INFY). Must be a stock, not an index."
+        ),
+        exchange_segment: Ollama::Tool::Function::Parameters::Property.new(
+          type: "string",
+          description: "Exchange segment (default: NSE_EQ)",
+          enum: %w[NSE_EQ BSE_EQ]
+        ),
+        min_score: Ollama::Tool::Function::Parameters::Property.new(
+          type: "integer",
+          description: "Minimum score threshold (default: 40)"
+        ),
+        verbose: Ollama::Tool::Function::Parameters::Property.new(
+          type: "boolean",
+          description: "Verbose output (default: false)"
+        )
+      },
+      required: %w[symbol]
+    )
+  )
+)
 
-  "options_scan" => lambda do |args|
-    symbol = args["symbol"] || args[:symbol]
-    exchange_segment = args["exchange_segment"] || args[:exchange_segment] || "IDX_I"
-    min_score = args["min_score"] || args[:min_score] || 40
-    verbose = args["verbose"] || args[:verbose] || false
+# Options Scan Tool - Structured definition
+options_scan_tool = Ollama::Tool.new(
+  type: "function",
+  function: Ollama::Tool::Function.new(
+    name: "options_scan",
+    description: "Scans for intraday options buying opportunities in INDICES only. " \
+                 "Use for NIFTY, SENSEX, BANKNIFTY. Do NOT use for stocks.",
+    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). Must be an index, not a stock.",
+          enum: %w[NIFTY SENSEX BANKNIFTY]
+        ),
+        exchange_segment: Ollama::Tool::Function::Parameters::Property.new(
+          type: "string",
+          description: "Exchange segment (default: IDX_I)",
+          enum: %w[IDX_I]
+        ),
+        min_score: Ollama::Tool::Function::Parameters::Property.new(
+          type: "integer",
+          description: "Minimum score threshold (default: 40)"
+        ),
+        verbose: Ollama::Tool::Function::Parameters::Property.new(
+          type: "boolean",
+          description: "Verbose output (default: false)"
+        )
+      },
+      required: %w[symbol]
+    )
+  )
+)
 
-    unless symbol
-      return { error: "symbol is required for options_scan" }
-    end
+# Technical Analysis Tool - Structured definition
+technical_analysis_tool = Ollama::Tool.new(
+  type: "function",
+  function: Ollama::Tool::Function.new(
+    name: "technical_analysis",
+    description: "Performs full technical analysis including trend, indicators, and patterns. " \
+                 "Can be used for both stocks and indices.",
+    parameters: Ollama::Tool::Function::Parameters.new(
+      type: "object",
+      properties: {
+        symbol: Ollama::Tool::Function::Parameters::Property.new(
+          type: "string",
+          description: "Symbol to analyze (stock or index)"
+        ),
+        exchange_segment: Ollama::Tool::Function::Parameters::Property.new(
+          type: "string",
+          description: "Exchange segment (default: NSE_EQ)",
+          enum: %w[NSE_EQ BSE_EQ NSE_FNO BSE_FNO IDX_I]
+        )
+      },
+      required: %w[symbol]
+    )
+  )
+)
 
-    # CRITICAL: Only allow indices, not stocks
-    unless %w[NIFTY SENSEX BANKNIFTY].include?(symbol.to_s.upcase)
-      return { error: "#{symbol} is not an index. Use swing_scan for stocks. Options are only available for indices (NIFTY, SENSEX, BANKNIFTY)." }
-    end
+# Define tools with structured Tool classes and callables
+tools = {
+  "swing_scan" => {
+    tool: swing_scan_tool,
+    callable: lambda do |symbol:, exchange_segment: "NSE_EQ", min_score: 40, verbose: false|
+      # CRITICAL: Only allow equity stocks, not indices
+      if %w[NIFTY SENSEX BANKNIFTY].include?(symbol.to_s.upcase)
+        return { error: "#{symbol} is an index, not a stock. Use options_scan for indices." }
+      end
 
-    begin
-      options_setups = agent.options_scanner.scan_for_options_setups(
-        symbol.to_s,
-        exchange_segment: exchange_segment.to_s,
-        min_score: min_score.to_i,
-        verbose: verbose
-      )
+      begin
+        candidates = agent.swing_scanner.scan_symbols(
+          [symbol.to_s],
+          exchange_segment: exchange_segment.to_s,
+          min_score: min_score.to_i,
+          verbose: verbose
+        )
 
-      if options_setups[:error]
-        { error: options_setups[:error] }
-      else
         {
           symbol: symbol,
           exchange_segment: exchange_segment,
-          setups_found: options_setups[:setups]&.length || 0,
-          setups: options_setups[:setups]&.map do |s|
+          candidates_found: candidates.length,
+          candidates: candidates.map do |c|
             {
-              type: s[:type],
-              strike: s[:strike],
-              score: s[:score],
-              iv: s[:iv],
-              recommendation: s[:recommendation]
+              symbol: c[:symbol],
+              score: c[:score],
+              trend: c[:analysis][:trend][:trend],
+              recommendation: c[:recommendation]
             }
-          end || []
+          end
         }
+      rescue StandardError => e
+        { error: e.message, backtrace: e.backtrace.first(3) }
       end
-    rescue StandardError => e
-      { error: e.message, backtrace: e.backtrace.first(3) }
     end
-  end,
-
-  "technical_analysis" => lambda do |args|
-    symbol = args["symbol"] || args[:symbol]
-    exchange_segment = args["exchange_segment"] || args[:exchange_segment] || "NSE_EQ"
+  },
+
+  "options_scan" => {
+    tool: options_scan_tool,
+    callable: lambda do |symbol:, exchange_segment: "IDX_I", min_score: 40, verbose: false|
+      # CRITICAL: Only allow indices, not stocks
+      unless %w[NIFTY SENSEX BANKNIFTY].include?(symbol.to_s.upcase)
+        error_message = "#{symbol} is not an index. Use swing_scan for stocks. " \
+                        "Options are only available for indices (NIFTY, SENSEX, BANKNIFTY)."
+        return { error: error_message }
+      end
 
-    unless symbol
-      return { error: "symbol is required for technical_analysis" }
+      begin
+        options_setups = agent.options_scanner.scan_for_options_setups(
+          symbol.to_s,
+          exchange_segment: exchange_segment.to_s,
+          min_score: min_score.to_i,
+          verbose: verbose
+        )
+
+        if options_setups[:error]
+          { error: options_setups[:error] }
+        else
+          underlying_price = options_setups.dig(:underlying_analysis, :current_price)
+          {
+            symbol: symbol,
+            exchange_segment: exchange_segment,
+            underlying_price: underlying_price,
+            setups_found: options_setups[:setups]&.length || 0,
+            setups: options_setups[:setups]&.map do |s|
+              {
+                type: s[:type],
+                strike: s[:strike],
+                score: s[:score],
+                iv: s[:iv],
+                ltp: s[:ltp],
+                recommendation: s[:recommendation]
+              }
+            end || []
+          }
+        end
+      rescue StandardError => e
+        { error: e.message, backtrace: e.backtrace.first(3) }
+      end
     end
+  },
 
-    begin
+  "technical_analysis" => {
+    tool: technical_analysis_tool,
+    callable: lambda do |symbol:, exchange_segment: "NSE_EQ"|
       analysis_result = agent.analysis_agent.analyze_symbol(
         symbol: symbol.to_s,
         exchange_segment: exchange_segment.to_s
@@ -200,7 +283,7 @@ tools = {
     rescue StandardError => e
       { error: e.message, backtrace: e.backtrace.first(3) }
     end
-  end
+  }
 }
 
 # Get user query and market context
@@ -254,6 +337,51 @@ executor = Ollama::Agent::Executor.new(
   max_steps: 20
 )
 
+def tool_messages(messages)
+  messages.select { |message| message[:role] == "tool" }
+end
+
+def print_tool_results(messages)
+  puts "Tool Results:"
+  tool_messages(messages).each do |message|
+    print_tool_message(message)
+  end
+end
+
+def print_tool_message(message)
+  tool_name = message[:name] || "unknown_tool"
+  puts "- #{tool_name}"
+  puts format_tool_content(message[:content])
+end
+
+def format_tool_content(content)
+  parsed = parse_tool_content(content)
+  return parsed if parsed.is_a?(String)
+
+  JSON.pretty_generate(parsed)
+end
+
+def parse_tool_content(content)
+  return content unless content.is_a?(String)
+
+  JSON.parse(content)
+rescue JSON::ParserError
+  content
+end
+
+def print_llm_summary(result)
+  return unless ENV["SHOW_LLM_SUMMARY"] == "true"
+
+  puts
+  puts "LLM Summary (unverified):"
+  puts result
+end
+
+def print_hallucination_warning
+  puts "No tool results were produced."
+  puts "LLM output suppressed to avoid hallucinated data."
+end
+
 # Run the agentic loop
 begin
   puts "🔄 Starting agentic tool-calling loop..."
@@ -268,7 +396,12 @@ begin
   puts "=" * 60
   puts "Agentic Analysis Complete"
   puts "=" * 60
-  puts result
+  if tool_messages(executor.messages).empty?
+    print_hallucination_warning
+  else
+    print_tool_results(executor.messages)
+    print_llm_summary(result)
+  end
 rescue Ollama::Error => e
   puts "❌ Error: #{e.message}"
   puts e.backtrace.first(5).join("\n") if e.backtrace