ollama-client 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f3a6bc948f8c0f17ccedf3f5f013c8d08d7315f189ef5dec237de4c74fbf257
-  data.tar.gz: 3ce70c7e7af44fcc550860877ca4acb4d1c00af13f70c746b984d855be95aeef
+  metadata.gz: 6b1ed7c3f2d09174f4127c92b0b22eef90fc3deb895dc86183d296a6a70cc3b4
+  data.tar.gz: f2d0737f5cbb77557fa736fb45f7a5c7c94fd939d1005c53d68e82d229844283
 SHA512:
-  metadata.gz: 7148b5b2dbe4dd8c5fb637b79837b1572283c1c2edaaa41df81fd75a347761809cdc7cbd9be8fd16d1cd99a33fbae25f716d436c0f1fde0304a6459338220335
-  data.tar.gz: 78f06aa33cc1d08bc1b915fe9c374c8949c091ea946ac25116ee8d6ec8c9d8080ca74f5c43bdfed91401051ed775b3bc245f808483346d164ecc7033a41d8f92
+  metadata.gz: 04dcc1b56d68d715727f5f51bd9511d1c4b633369435e4f95008b2bb826d988d00df6fa307dc900fb0c8365b6f4bc0e111e17b4c74deb9c25360bfa36f6148cd
+  data.tar.gz: 8ea4bef981e5601dddd258a1f0dab481e76601f765bddc9783098bedc144cd1d0ceeb9e30b185541fa688ea8519fc796356a9ffe6abbc437a7dae6d93b757852

data/examples/advanced_multi_step_agent.rb

@@ -118,6 +118,45 @@ class MultiStepAgent
           break
         end
 
+        # Prevent infinite loops - if we've done the same action 3+ times, force progression
+        recent_actions = @state[:steps_completed].last(3).map { |s| s[:action] }
+        if recent_actions.length == 3 && recent_actions.uniq.length == 1
+          puts "⚠️  Detected repetitive actions - forcing workflow progression"
+          # Force next phase
+          if recent_actions.first == "collect"
+            puts "   → Moving to analysis phase"
+            decision["action"]["type"] = "analyze"
+            decision["action"]["parameters"] = { "target" => "collected_data" }
+            result = execute_action(decision)
+            @state[:steps_completed] << {
+              step: decision["step"],
+              action: "analyze",
+              result: result
+            }
+          elsif recent_actions.first == "analyze"
+            puts "   → Moving to validation phase"
+            decision["action"]["type"] = "validate"
+            decision["action"]["parameters"] = { "type" => "results" }
+            result = execute_action(decision)
+            @state[:steps_completed] << {
+              step: decision["step"],
+              action: "validate",
+              result: result
+            }
+          elsif recent_actions.first == "validate"
+            puts "   → Completing workflow"
+            decision["action"]["type"] = "complete"
+            result = execute_action(decision)
+            @state[:steps_completed] << {
+              step: decision["step"],
+              action: "complete",
+              result: result
+            }
+            puts "\n✅ Workflow completed successfully!"
+            break
+          end
+        end
+
         # Handle risk
         if decision["risk_assessment"] && decision["risk_assessment"]["level"] == "high"
           puts "⚠️  High risk detected - proceeding with caution"
@@ -147,31 +186,61 @@ class MultiStepAgent
 
   private
 
-  def build_context(_goal:)
+  def build_context(goal:) # rubocop:disable Lint/UnusedMethodArgument
     {
       steps_completed: @state[:steps_completed].map { |s| s[:action] },
       data_collected: @state[:data_collected].keys,
-      error_count: @state[:errors].length
+      error_count: @state[:errors].length,
+      step_count: @state[:steps_completed].length
     }
   end
 
   def build_prompt(goal:, context:)
+    step_count = context[:step_count]
+    completed_actions = context[:steps_completed]
+    collected_data = context[:data_collected]
+
+    # Determine current phase based on what's been done
+    phase = if completed_actions.empty?
+              "collection"
+            elsif completed_actions.include?("collect") && !completed_actions.include?("analyze")
+              "analysis"
+            elsif completed_actions.include?("analyze") && !completed_actions.include?("validate")
+              "validation"
+            else
+              "completion"
+            end
+
     <<~PROMPT
       Goal: #{goal}
 
-      Workflow State:
-      - Steps completed: #{context[:steps_completed].join(", ") || "none"}
-      - Data collected: #{context[:data_collected].join(", ") || "none"}
-      - Errors encountered: #{context[:error_count]}
-
-      Analyze the current state and decide the next action.
-      Consider:
-      1. What data still needs to be collected?
-      2. What analysis is needed?
-      3. What validation is required?
-      4. When should the workflow complete?
+      Current Phase: #{phase}
+      Steps completed: #{step_count}
+      Actions taken: #{completed_actions.join(", ") || "none"}
+      Data collected: #{collected_data.join(", ") || "none"}
+      Errors encountered: #{context[:error_count]}
+
+      Workflow Phases (in order):
+      1. COLLECTION: Collect initial data (user data, patterns, etc.)
+      2. ANALYSIS: Analyze collected data for patterns and insights
+      3. VALIDATION: Validate the analysis results
+      4. COMPLETION: Finish the workflow
+
+      Current State Analysis:
+      - You are in the #{phase} phase
+      - You have completed #{step_count} steps
+      - You have collected: #{collected_data.any? ? collected_data.join(", ") : "nothing yet"}
+
+      Decision Guidelines:
+      - If in COLLECTION phase and no data collected: use action "collect" with specific data_type (e.g., "user_data", "patterns")
+      - If data collected but not analyzed: use action "analyze" with target
+      - If analyzed but not validated: use action "validate"
+      - If all phases done: use action "complete"
+      - AVOID repeating the same action multiple times unless necessary
+      - Progress through phases: collect → analyze → validate → complete
 
       Provide a structured decision with high confidence (>0.7) if possible.
+      Set step number to #{step_count + 1}.
     PROMPT
   end
 
@@ -198,15 +267,21 @@ class MultiStepAgent
 
     case action_type
     when "collect"
-      data_key = params["data_type"] || "unknown"
+      data_key = params["data_type"] || params["key"] || "user_data"
+      # Prevent collecting the same generic data repeatedly
+      if @state[:data_collected].key?(data_key) && data_key.match?(/^(missing|unknown|data)$/i) && !@state[:data_collected].key?("user_data")
+        data_key = "user_data"
+      end
       puts "   📥 Collecting: #{data_key}"
       @state[:data_collected][data_key] = "collected_at_#{Time.now.to_i}"
       { status: "collected", key: data_key }
 
     when "analyze"
-      target = params["target"] || "data"
+      target = params["target"] || "collected_data"
       puts "   🔍 Analyzing: #{target}"
-      { status: "analyzed", target: target, insights: "analysis_complete" }
+      # Mark that analysis has been done
+      @state[:data_collected]["analysis_complete"] = true
+      { status: "analyzed", target: target, insights: "Patterns identified in collected data" }
 
     when "transform"
       transformation = params["type"] || "default"
@@ -214,9 +289,11 @@ class MultiStepAgent
       { status: "transformed", type: transformation }
 
     when "validate"
-      validation_type = params["type"] || "general"
+      validation_type = params["type"] || "results"
       puts "   ✓ Validating: #{validation_type}"
-      { status: "validated", type: validation_type }
+      # Mark that validation has been done
+      @state[:data_collected]["validation_complete"] = true
+      { status: "validated", type: validation_type, result: "All checks passed" }
 
     when "complete"
       puts "   ✅ Completing workflow"

data/examples/dhanhq/README.md

@@ -0,0 +1,236 @@
+# DhanHQ Agent - Complete Trading & Technical Analysis System
+
+## Features
+
+### Core Capabilities
+- **Data Retrieval**: 6 DhanHQ Data APIs (Market Quote, LTP, Depth, Historical, Options, Chain)
+- **Trading Tools**: Order parameter building (regular, super orders, cancel)
+- **LLM-Powered Decisions**: Ollama for intelligent market analysis and decision making
+- **LLM Orchestration**: AI decides what symbols to analyze, which exchange segments, and what analysis to run
+
+### Technical Analysis (NEW!)
+- **Trend Analysis**: Uptrend, downtrend, sideways detection with strength calculation
+- **Market Structure**: SMC (Smart Money Concepts) analysis
+  - Order blocks identification
+  - Liquidity zones (buy-side/sell-side)
+  - Structure breaks detection
+- **Pattern Recognition**:
+  - Candlestick patterns (engulfing, hammer, shooting star, etc.)
+  - Chart patterns (head & shoulders, double top/bottom)
+- **Technical Indicators**:
+  - Moving Averages (SMA, EMA)
+  - RSI (Relative Strength Index)
+  - MACD (Moving Average Convergence Divergence)
+  - Bollinger Bands
+  - ATR (Average True Range)
+  - Support & Resistance levels
+
+### Scanners (NEW!)
+- **Swing Trading Scanner**: Find swing trading candidates based on technical analysis
+- **Intraday Options Scanner**: Find intraday options buying opportunities with IV/OI analysis
+
+## Structure
+
+```
+dhanhq/
+├── agents/                    # Agent classes (LLM decision makers)
+│   ├── base_agent.rb
+│   ├── data_agent.rb
+│   ├── trading_agent.rb
+│   ├── technical_analysis_agent.rb
+│   └── orchestrator_agent.rb  # NEW - LLM decides what to analyze
+├── services/                  # Service classes (API executors)
+│   ├── base_service.rb
+│   ├── data_service.rb
+│   └── trading_service.rb
+├── analysis/                  # Technical analysis modules (NEW)
+│   ├── market_structure.rb    # SMC, trend, structure breaks
+│   ├── pattern_recognizer.rb # Candlestick & chart patterns
+│   └── trend_analyzer.rb     # Comprehensive trend analysis
+├── indicators/                # Technical indicators (NEW)
+│   └── technical_indicators.rb # RSI, MACD, MA, Bollinger, ATR, etc.
+├── scanners/                  # Trading scanners (NEW)
+│   ├── swing_scanner.rb      # Swing trading candidates
+│   └── intraday_options_scanner.rb # Options opportunities
+├── builders/                  # Builder classes
+│   └── market_context_builder.rb
+├── utils/                     # Utility classes
+│   ├── instrument_helper.rb
+│   ├── parameter_normalizer.rb
+│   ├── parameter_cleaner.rb
+│   ├── trading_parameter_normalizer.rb
+│   └── rate_limiter.rb
+├── schemas/                   # JSON schemas for LLM
+│   └── agent_schemas.rb
+└── dhanhq_agent.rb            # Main entry point
+```
+
+## Design Principles
+
+- **SOLID**: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion
+- **KISS**: Keep It Simple, Stupid
+- **DRY**: Don't Repeat Yourself
+- **Namespacing**: All classes under `DhanHQ` module
+
+## Usage
+
+### Basic Usage
+
+```ruby
+require_relative "dhanhq/dhanhq_agent"
+
+agent = DhanHQ::Agent.new
+
+# Data retrieval
+decision = agent.data_agent.analyze_and_decide(market_context: "...")
+result = agent.data_agent.execute_decision(decision)
+
+# Trading
+trading_decision = agent.trading_agent.analyze_and_decide(market_context: "...")
+order_params = agent.trading_agent.execute_decision(trading_decision)
+```
+
+### LLM Orchestration (NEW!)
+
+```ruby
+# Let LLM decide what to analyze
+plan = agent.orchestrator_agent.decide_analysis_plan(
+  market_context: "NIFTY is at 25,790, RELIANCE showing strength",
+  user_query: "Find swing trading opportunities in banking stocks"
+)
+
+# Plan contains:
+# - analysis_plan: Array of tasks with symbol, exchange_segment, analysis_type
+# - reasoning: Why the LLM chose this plan
+
+# Execute the plan
+plan["analysis_plan"].each do |task|
+  case task["analysis_type"]
+  when "technical_analysis"
+    agent.analysis_agent.analyze_symbol(...)
+  when "swing_scan"
+    agent.swing_scanner.scan_symbols(...)
+  when "options_scan"
+    agent.options_scanner.scan_for_options_setups(...)
+  end
+end
+```
+
+### Technical Analysis
+
+```ruby
+# Analyze a symbol
+analysis = agent.analysis_agent.analyze_symbol(
+  symbol: "RELIANCE",
+  exchange_segment: "NSE_EQ"
+)
+
+# Get swing trading recommendation
+recommendation = agent.analysis_agent.generate_recommendation(
+  analysis,
+  trading_style: :swing
+)
+```
+
+### Scanning
+
+```ruby
+# Swing trading scanner
+candidates = agent.swing_scanner.scan_symbols(
+  ["RELIANCE", "TCS", "INFY"],
+  exchange_segment: "NSE_EQ"
+)
+
+# Intraday options scanner
+options_setups = agent.options_scanner.scan_for_options_setups(
+  "NIFTY",
+  exchange_segment: "IDX_I"
+)
+```
+
+## Technical Analysis Capabilities
+
+### Trend Analysis
+- Detects uptrend, downtrend, sideways
+- Calculates trend strength percentage
+- Uses moving averages for confirmation
+
+### SMC (Smart Money Concepts)
+- **Order Blocks**: Identifies institutional order zones
+- **Liquidity Zones**: Finds buy-side and sell-side liquidity areas
+- **Structure Breaks**: Detects trend changes and breakouts
+
+### Pattern Recognition
+- **Candlestick Patterns**: Engulfing, hammer, shooting star, three white soldiers/crows
+- **Chart Patterns**: Head & shoulders, double top/bottom
+
+### Indicators
+- **RSI**: Overbought/oversold conditions
+- **MACD**: Momentum and trend changes
+- **Moving Averages**: Trend confirmation
+- **Bollinger Bands**: Volatility and mean reversion
+- **ATR**: Volatility measurement
+- **Support/Resistance**: Key price levels
+
+## Scanner Features
+
+### Swing Trading Scanner
+- Scores symbols based on:
+  - Trend strength
+  - RSI levels (prefers 40-60 zone)
+  - MACD bullish crossovers
+  - Structure breaks
+  - Pattern recognition
+- Returns top candidates sorted by score
+
+### Intraday Options Scanner
+- Analyzes underlying trend
+- Finds ATM/near-ATM strikes
+- Considers:
+  - Implied Volatility (lower is better for buying)
+  - Open Interest (higher is better)
+  - Volume (higher is better)
+  - Trend alignment
+  - RSI levels
+- Returns top 5 setups with scores
+
+## Running
+
+### Full Demo (All Features)
+```bash
+ruby examples/dhanhq/dhanhq_agent.rb
+```
+
+This will demonstrate:
+1. Data retrieval with LLM decisions
+2. Trading order parameter building
+3. Technical analysis for a symbol
+4. Swing trading scanner
+5. Intraday options scanner
+
+### Technical Analysis Only
+```bash
+# LLM decides what to analyze (default)
+ruby examples/dhanhq/technical_analysis_runner.rb
+
+# With custom query
+ruby examples/dhanhq/technical_analysis_runner.rb "Find options opportunities for NIFTY"
+
+# With custom query and market context
+ruby examples/dhanhq/technical_analysis_runner.rb "Analyze banking stocks" "Banking sector showing strength"
+
+# Show manual examples too (for comparison)
+SHOW_MANUAL_EXAMPLES=true ruby examples/dhanhq/technical_analysis_runner.rb
+```
+
+**LLM-Powered Orchestration:**
+The LLM decides:
+- Which symbols to analyze (e.g., "RELIANCE", "NIFTY", "BANKNIFTY")
+- Which exchange segments to use (NSE_EQ, IDX_I, etc.)
+- What type of analysis to run (technical_analysis, swing_scan, options_scan)
+- Priority order of analysis tasks
+
+This makes the system truly autonomous - you just ask what you want, and the LLM figures out how to get it.
+
+**Manual Examples (optional):**
+If `SHOW_MANUAL_EXAMPLES=true`, it also runs fixed examples for comparison.

data/examples/dhanhq/agents/base_agent.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "../utils/parameter_normalizer"
+require_relative "../utils/parameter_cleaner"
+
+module DhanHQ
+  module Agents
+    # Base class for all agents with common LLM interaction logic
+    class BaseAgent
+      MIN_CONFIDENCE = 0.6
+
+      def initialize(ollama_client:, schema:)
+        @ollama_client = ollama_client
+        @schema = schema
+      end
+
+      def analyze_and_decide(market_context:)
+        prompt = build_analysis_prompt(market_context: market_context)
+
+        decision = call_llm(prompt)
+        return invalid_decision unless valid_decision?(decision)
+
+        decision = clean_parameters(decision)
+        return low_confidence_decision(decision) if low_confidence?(decision)
+
+        decision
+      rescue Ollama::Error => e
+        error_decision(e.message)
+      rescue StandardError => e
+        error_decision(e.message)
+      end
+
+      protected
+
+      def build_analysis_prompt(market_context:)
+        raise NotImplementedError, "Subclasses must implement build_analysis_prompt"
+      end
+
+      private
+
+      def call_llm(prompt)
+        @ollama_client.generate(prompt: prompt, schema: @schema)
+      end
+
+      def valid_decision?(decision)
+        decision.is_a?(Hash) && decision["confidence"]
+      end
+
+      def clean_parameters(decision)
+        return decision unless decision["parameters"].is_a?(Hash)
+
+        cleaned_params = DhanHQ::Utils::ParameterCleaner.clean(decision["parameters"])
+        decision.merge("parameters" => cleaned_params)
+      end
+
+      def low_confidence?(decision)
+        decision["confidence"] < MIN_CONFIDENCE
+      end
+
+      def invalid_decision
+        { action: "no_action", reason: "invalid_decision" }
+      end
+
+      def low_confidence_decision(decision)
+        confidence_pct = (decision["confidence"] * 100).round
+        puts "⚠️  Low confidence (#{confidence_pct}%) - skipping action"
+        { action: "no_action", reason: "low_confidence" }
+      end
+
+      def error_decision(message)
+        puts "❌ Ollama error: #{message}"
+        { action: "no_action", reason: "error", error: message }
+      end
+    end
+  end
+end

data/examples/dhanhq/agents/data_agent.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "base_agent"
+require_relative "../schemas/agent_schemas"
+require_relative "../services/data_service"
+
+module DhanHQ
+  module Agents
+    # Agent for market data retrieval decisions using LLM
+    class DataAgent < BaseAgent
+      def initialize(ollama_client:)
+        super(ollama_client: ollama_client, schema: DhanHQ::Schemas::AgentSchemas::DATA_AGENT_SCHEMA)
+        @data_service = DhanHQ::Services::DataService.new
+      end
+
+      def execute_decision(decision)
+        action = decision["action"]
+        params = DhanHQ::Utils::ParameterNormalizer.normalize(decision["parameters"] || {})
+
+        @data_service.execute(action: action, params: params)
+      end
+
+      protected
+
+      def build_analysis_prompt(market_context:)
+        <<~PROMPT
+          Analyze the following market situation and decide the best data retrieval action:
+
+          Market Context:
+          #{market_context}
+
+          Available Actions (DATA ONLY - NO TRADING):
+          - get_market_quote: Get market quote using Instrument.quote convenience method (requires: symbol OR security_id as STRING, exchange_segment as STRING)
+          - get_live_ltp: Get live last traded price using Instrument.ltp convenience method (requires: symbol OR security_id as STRING, exchange_segment as STRING)
+          - get_market_depth: Get full market depth (bid/ask levels) using Instrument.quote convenience method (requires: symbol OR security_id as STRING, exchange_segment as STRING)
+          - get_historical_data: Get historical data using Instrument.daily/intraday convenience methods (requires: symbol OR security_id as STRING, exchange_segment as STRING, from_date, to_date, optional: interval, expiry_code)
+          - get_expired_options_data: Get expired options historical data (requires: symbol OR security_id as STRING, exchange_segment as STRING, expiry_date; optional: expiry_code, interval, instrument, expiry_flag, strike, drv_option_type, required_data)
+          - get_option_chain: Get option chain using Instrument.expiry_list/option_chain convenience methods (requires: symbol OR security_id as STRING, exchange_segment as STRING, optional: expiry)
+          - no_action: Take no action if unclear what data is needed
+
+          CRITICAL: Each API call handles ONLY ONE symbol at a time. If you need data for multiple symbols, choose ONE symbol for this decision.
+          - symbol must be a SINGLE STRING value (e.g., "NIFTY" or "RELIANCE"), NOT an array
+          - exchange_segment must be a SINGLE STRING value (e.g., "NSE_EQ" or "IDX_I"), NOT an array
+          - All APIs use Instrument.find() which expects SYMBOL (e.g., "NIFTY", "RELIANCE"), not security_id
+          - Instrument convenience methods automatically use the instrument's security_id, exchange_segment, and instrument attributes
+          - Use symbol when possible for better compatibility
+          Examples:
+            - For NIFTY: symbol="NIFTY", exchange_segment="IDX_I"
+            - For RELIANCE: symbol="RELIANCE", exchange_segment="NSE_EQ"
+          Valid exchange_segments: NSE_EQ, NSE_FNO, NSE_CURRENCY, BSE_EQ, BSE_FNO, BSE_CURRENCY, MCX_COMM, IDX_I
+
+          Decision Criteria:
+          - Only take actions with confidence > 0.6
+          - Focus on data retrieval, not trading decisions
+          - Provide all required parameters for the chosen action
+
+          Respond with a JSON object containing:
+          - action: one of the available actions
+          - reasoning: why this action was chosen
+          - confidence: your confidence level (0-1)
+          - parameters: object with required parameters for the action
+        PROMPT
+      end
+    end
+  end
+end

data/examples/dhanhq/agents/orchestrator_agent.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "base_agent"
+require_relative "../schemas/agent_schemas"
+
+module DhanHQ
+  module Agents
+    # Orchestrator agent that uses LLM to decide what to analyze
+    class OrchestratorAgent < BaseAgent
+      def initialize(ollama_client:)
+        super(ollama_client: ollama_client, schema: build_orchestration_schema)
+      end
+
+      def decide_analysis_plan(market_context: "", user_query: "")
+        prompt = build_orchestration_prompt(market_context: market_context, user_query: user_query)
+
+        begin
+          plan = @ollama_client.generate(
+            prompt: prompt,
+            schema: build_orchestration_schema
+          )
+
+          return { error: "Invalid plan" } unless plan.is_a?(Hash) && plan["analysis_plan"]
+
+          plan
+        rescue Ollama::Error => e
+          { error: e.message }
+        end
+      end
+
+      protected
+
+      def build_analysis_prompt(market_context:)
+        # Not used, but required by base class
+        ""
+      end
+
+      private
+
+      def build_orchestration_prompt(market_context:, user_query:)
+        <<~PROMPT
+          You are a trading analysis orchestrator. Based on the market context and user query, decide what technical analysis to perform.
+
+          Market Context:
+          #{market_context.empty? ? 'No specific market context provided' : market_context}
+
+          User Query:
+          #{user_query.empty? ? 'No specific query - analyze current market opportunities' : user_query}
+
+          Your task is to create an analysis plan that includes:
+          1. Which symbols to analyze:
+             - Equity stocks: "RELIANCE", "TCS", "INFY", "HDFC" (use NSE_EQ or BSE_EQ)
+             - Indices: "NIFTY", "SENSEX", "BANKNIFTY" (use IDX_I)
+          2. Which exchange segments to use:
+             - NSE_EQ or BSE_EQ for equity stocks
+             - IDX_I for indices (NIFTY, SENSEX, BANKNIFTY)
+          3. What type of analysis to perform:
+             - "technical_analysis": Full technical analysis (trend, indicators, patterns) - can be used for both stocks and indices
+             - "swing_scan": Scan for swing trading opportunities - ONLY for equity stocks, NEVER for indices
+             - "options_scan": Scan for intraday options opportunities - ONLY for indices (NIFTY, SENSEX, BANKNIFTY)
+             - "all": Run all applicable analysis types (swing_scan only for stocks, options_scan only for indices)
+          4. Priority order (which symbols/analyses to run first)
+
+          Consider:
+          - If user mentions specific stocks, prioritize those
+          - If user asks about "swing trading", use swing_scan ONLY for equity stocks (not indices)
+          - If user asks about "options" or "intraday", use options_scan
+          - If no specific query, scan for opportunities across multiple symbols
+          - CRITICAL: Index symbols (NIFTY, SENSEX, BANKNIFTY) are INDICES, not stocks
+            * Indices should ONLY be analyzed with options_scan (for options buying opportunities)
+            * Indices should NEVER be analyzed with swing_scan (swing trading is for stocks only)
+          - For options, use index symbols (NIFTY, SENSEX, BANKNIFTY) with IDX_I segment
+          - For swing trading, use ONLY equity symbols (RELIANCE, TCS, INFY, HDFC) with NSE_EQ or BSE_EQ segment
+
+          Respond with a JSON object containing your analysis plan.
+        PROMPT
+      end
+
+      def build_orchestration_schema
+        {
+          "type" => "object",
+          "required" => ["analysis_plan", "reasoning"],
+          "properties" => {
+            "analysis_plan" => {
+              "type" => "array",
+              "items" => {
+                "type" => "object",
+                "required" => ["symbol", "exchange_segment", "analysis_type"],
+                "properties" => {
+                  "symbol" => {
+                    "type" => "string",
+                    "description" => "Symbol to analyze (e.g., 'RELIANCE', 'NIFTY', 'TCS')"
+                  },
+                  "exchange_segment" => {
+                    "type" => "string",
+                    "enum" => ["NSE_EQ", "NSE_FNO", "NSE_CURRENCY", "BSE_EQ", "BSE_FNO",
+                               "BSE_CURRENCY", "MCX_COMM", "IDX_I"],
+                    "description" => "Exchange segment for the symbol"
+                  },
+                  "analysis_type" => {
+                    "type" => "string",
+                    "enum" => ["technical_analysis", "swing_scan", "options_scan", "all"],
+                    "description" => "Type of analysis to perform"
+                  },
+                  "priority" => {
+                    "type" => "number",
+                    "description" => "Priority (1 = highest, lower numbers = higher priority)"
+                  }
+                }
+              }
+            },
+            "reasoning" => {
+              "type" => "string",
+              "description" => "Why you chose this analysis plan"
+            }
+          }
+        }
+      end
+    end
+  end
+end