ollama-client 0.2.2 → 0.2.4

data/examples/multi_step_agent_with_external_data.rb

@@ -0,0 +1,368 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Use local code instead of installed gem
+$LOAD_PATH.unshift(File.expand_path("lib", __dir__))
+require "ollama_client"
+require "json"
+require "fileutils"
+
+puts "\n=== MULTI-STEP AGENT WITH EXTERNAL DATA TEST ===\n"
+
+# Configuration via environment variables (defaults for local testing)
+BASE_URL = ENV.fetch("OLLAMA_BASE_URL", "http://localhost:11434")
+
+def client_for(model:, temperature:, timeout:)
+  config = Ollama::Config.new
+  config.base_url = BASE_URL
+  config.model = model
+  config.temperature = temperature
+  config.timeout = timeout
+  config.retries = 2
+  Ollama::Client.new(config: config)
+end
+
+# ------------------------------------------------------------
+# PLANNER SETUP (STATELESS)
+# ------------------------------------------------------------
+
+planner_client = client_for(
+  model: ENV.fetch("OLLAMA_MODEL", "llama3.1:8b"),
+  temperature: 0,
+  timeout: 40
+)
+
+planner = Ollama::Agent::Planner.new(planner_client)
+
+decision_schema = {
+  "type" => "object",
+  "required" => %w[action reason],
+  "properties" => {
+    "action" => {
+      "type" => "string",
+      "enum" => %w[read_file read_reference analyze_with_reference finish]
+    },
+    "reason" => { "type" => "string" }
+  }
+}
+
+# ------------------------------------------------------------
+# EXECUTOR SETUP (STATEFUL)
+# ------------------------------------------------------------
+
+test_dir = File.expand_path("test_files", __dir__)
+
+tools = {
+  "read_file" => lambda do |path:|
+    full_path = File.expand_path(path, test_dir)
+    return { error: "Path must be within test_files directory" } unless full_path.start_with?(test_dir)
+
+    return { error: "File not found: #{path}" } unless File.exist?(full_path)
+
+    {
+      path: path,
+      content: File.read(full_path),
+      size: File.size(full_path)
+    }
+  end,
+
+  "read_reference" => lambda do |reference_name:|
+    # Read external reference files
+    reference_files = {
+      "style_guide" => "ruby_style_guide.txt",
+      "checklist" => "code_review_checklist.txt"
+    }
+
+    filename = reference_files[reference_name.to_s]
+    unless filename
+      return { error: "Unknown reference: #{reference_name}. Available: #{reference_files.keys.join(", ")}" }
+    end
+
+    full_path = File.expand_path(filename, test_dir)
+    return { error: "Reference file not found: #{filename}" } unless File.exist?(full_path)
+
+    {
+      reference_name: reference_name,
+      content: File.read(full_path),
+      size: File.size(full_path)
+    }
+  end
+}
+
+executor_client = client_for(
+  model: ENV.fetch("OLLAMA_MODEL", "llama3.1:8b"),
+  temperature: 0.2,
+  timeout: 60
+)
+
+executor = Ollama::Agent::Executor.new(
+  executor_client,
+  tools: tools
+)
+
+def step_limit_reached?(step, max_steps)
+  return false if step <= max_steps
+
+  puts "\n⚠️  Maximum steps reached (#{max_steps})"
+  true
+end
+
+def build_status(context, step)
+  {
+    file_read: context[:file_read] ? "YES" : "NO",
+    references_read: context[:references_read].empty? ? "NONE" : context[:references_read].join(", "),
+    has_analysis: context[:analysis] ? "YES" : "NO",
+    step_number: step
+  }
+end
+
+def missing_references(references_read)
+  %w[style_guide checklist] - references_read
+end
+
+def early_plan_for(context)
+  return { "action" => "finish", "reason" => "Analysis complete" } if context[:analysis]
+
+  if context[:file_read] && context[:references_read].length >= 2
+    return { "action" => "analyze_with_reference",
+             "reason" => "File and all references read, ready to analyze" }
+  end
+
+  return nil unless context[:file_read]
+
+  missing_refs = missing_references(context[:references_read])
+  return nil if missing_refs.empty?
+
+  { "action" => "read_reference",
+    "reason" => "File read, need to read missing references: #{missing_refs.join(", ")}" }
+end
+
+def planner_prompt(status)
+  <<~PROMPT
+    You are a planning agent for code analysis with external reference data.
+
+    Available actions:
+    - read_file: Read the target code file (ONLY if file_read is NO)
+    - read_reference: Read external reference data (style_guide or checklist) - ONLY if not already read
+    - analyze_with_reference: Analyze code using the reference data (ONLY if file_read is YES and BOTH references are read)
+    - finish: Complete task (ONLY if analysis exists)
+
+    Current Status:
+    #{status.to_json}
+
+    CRITICAL RULES (follow strictly in order):
+    1. If file_read is NO → use read_file (DO NOT read file if already read)
+    2. If file_read is YES and references_read is missing style_guide or checklist → use read_reference for the missing one
+    3. If file_read is YES and BOTH references are read and analysis is NO → use analyze_with_reference
+    4. If analysis exists → use finish
+
+    DO NOT:
+    - Read file if file_read is YES
+    - Read a reference if it's already in references_read
+    - Analyze if analysis already exists
+    - Finish if analysis does not exist
+
+    Decide the next action. Return ONLY valid JSON.
+  PROMPT
+end
+
+def plan_next_action(planner, decision_schema, status, context)
+  early_plan = early_plan_for(context)
+  return early_plan if early_plan
+
+  planner.run(prompt: planner_prompt(status), schema: decision_schema)
+end
+
+def handle_plan(plan, context, executor, test_dir)
+  case plan["action"]
+  when "read_file"
+    handle_read_file(context, test_dir)
+  when "read_reference"
+    handle_read_reference(context, test_dir)
+  when "analyze_with_reference"
+    handle_analyze_with_reference(context, executor, test_dir)
+  when "finish"
+    handle_finish
+  else
+    raise "Unknown action: #{plan["action"]}"
+  end
+end
+
+def handle_read_file(context, test_dir)
+  if context[:file_read]
+    puts "\n⚠️  File already read, skipping..."
+    return :skip
+  end
+
+  puts "\n→ Executor: reading target file"
+
+  full_path = File.expand_path(context[:target_file], test_dir)
+  if File.exist?(full_path)
+    context[:file_content] = File.read(full_path)
+    context[:file_read] = true
+    puts "\n✅ File content read (#{context[:file_content].length} bytes)"
+  else
+    puts "\n❌ File not found: #{context[:target_file]}"
+    context[:file_read] = false
+  end
+
+  :continue
+end
+
+def reference_file_name(reference_name)
+  reference_name == "style_guide" ? "ruby_style_guide.txt" : "code_review_checklist.txt"
+end
+
+def handle_read_reference(context, test_dir)
+  puts "\n→ Executor: reading reference data"
+
+  references_to_read = missing_references(context[:references_read])
+  if references_to_read.empty?
+    puts "\n⚠️  All references already read"
+    return :skip
+  end
+
+  reference_name = references_to_read.first
+  puts "\nReading reference: #{reference_name}"
+
+  ref_file = reference_file_name(reference_name)
+  ref_path = File.expand_path(ref_file, test_dir)
+
+  if File.exist?(ref_path)
+    context[:reference_data][reference_name] = File.read(ref_path)
+    context[:references_read] << reference_name
+    puts "\n✅ Reference '#{reference_name}' loaded (#{context[:reference_data][reference_name].length} bytes)"
+  else
+    puts "\n❌ Reference file not found: #{ref_file}"
+  end
+
+  :continue
+end
+
+def analysis_system_prompt
+  <<~PROMPT
+    You are a Ruby code analysis agent. Analyze code using the provided reference guidelines and checklists.
+    Compare the code against the reference standards and provide specific recommendations.
+  PROMPT
+end
+
+def analysis_user_prompt(code, reference_context)
+  <<~PROMPT
+    Analyze this Ruby code using the reference data:
+
+    CODE TO ANALYZE:
+    #{code}
+
+    REFERENCE DATA:
+    #{reference_context}
+
+    Provide a detailed analysis that:
+    1. Compares the code against the style guide
+    2. Checks items from the code review checklist
+    3. Provides specific, actionable recommendations
+    4. References specific guidelines from the reference data
+
+    Keep your analysis focused and reference the external data when making recommendations.
+  PROMPT
+end
+
+def handle_analyze_with_reference(context, executor, _test_dir)
+  if context[:analysis]
+    puts "\n⚠️  Analysis already complete, skipping..."
+    return :skip
+  end
+
+  unless context[:file_read]
+    puts "\n❌ Cannot analyze: file not read yet"
+    return :skip
+  end
+
+  if context[:references_read].length < 2
+    puts "\n❌ Cannot analyze: need both references (have: #{context[:references_read].join(", ")})"
+    return :skip
+  end
+
+  puts "\n→ Executor: analyzing code using reference data"
+
+  reference_context = context[:reference_data].map do |name, content|
+    "#{name.upcase}:\n#{content}\n"
+  end.join("\n---\n\n")
+
+  result = executor.run(
+    system: analysis_system_prompt,
+    user: analysis_user_prompt(context[:file_content], reference_context)
+  )
+
+  puts "\nExecutor result:"
+  puts result
+  puts "\n#{"=" * 60}"
+
+  context[:analysis] = result
+  :continue
+end
+
+def handle_finish
+  puts "\n→ Agent finished"
+  :finish
+end
+
+# ------------------------------------------------------------
+# AGENT LOOP
+# ------------------------------------------------------------
+
+context = {
+  target_file: "user_creator.rb",
+  file_read: false,
+  file_content: nil,
+  references_read: [],
+  reference_data: {},
+  analysis: nil
+}
+
+step = 0
+max_steps = 15
+
+loop do
+  step += 1
+  puts "\n→ Planner step #{step}"
+
+  break if step_limit_reached?(step, max_steps)
+
+  status = build_status(context, step)
+  plan = plan_next_action(planner, decision_schema, status, context)
+  pp plan
+
+  result = handle_plan(plan, context, executor, test_dir)
+  break if result == :finish
+  next if result == :skip
+end
+
+# ------------------------------------------------------------
+# FINAL ASSERTIONS
+# ------------------------------------------------------------
+
+puts "\n→ Assertions"
+
+success = true
+
+unless context[:file_read]
+  puts "❌ No file read"
+  success = false
+end
+
+unless context[:references_read].any?
+  puts "❌ No references read"
+  success = false
+end
+
+unless context[:analysis]
+  puts "❌ No analysis performed"
+  success = false
+end
+
+raise "❌ MULTI-STEP AGENT WITH EXTERNAL DATA FAILED" unless success
+
+puts "\n✅ MULTI-STEP AGENT WITH EXTERNAL DATA PASSED"
+puts "\nReferences used: #{context[:references_read].join(", ")}"
+puts "\nAnalysis length: #{context[:analysis].length} characters"
+puts "\n=== END ===\n"

data/{test_dhanhq_tool_calling.rb → examples/test_dhanhq_tool_calling.rb}

@@ -6,6 +6,7 @@
 
 require_relative "lib/ollama_client"
 require_relative "examples/dhanhq_tools"
+require "date"
 
 puts "\n=== DHANHQ TOOL CALLING TEST ===\n"
 puts "Using chat_raw() to access tool_calls\n"
@@ -68,7 +69,11 @@ historical_data_tool = Ollama::Tool.new(
   type: "function",
   function: Ollama::Tool::Function.new(
     name: "get_historical_data",
-    description: "Get historical price data (OHLCV) for a symbol. Supports daily, weekly, monthly intervals.",
+    description: "Get historical price data (OHLCV) or technical indicators. " \
+                 "Use interval for intraday data (1, 5, 15, 25, 60 minutes). " \
+                 "Omit interval for daily data. " \
+                 "Set calculate_indicators=true to get technical indicators " \
+                 "(RSI, MACD, SMA, EMA, Bollinger Bands, ATR) instead of raw data.",
     parameters: Ollama::Tool::Function::Parameters.new(
       type: "object",
       properties: {
@@ -83,8 +88,9 @@ historical_data_tool = Ollama::Tool.new(
         ),
         interval: Ollama::Tool::Function::Parameters::Property.new(
           type: "string",
-          description: "Data interval",
-          enum: %w[daily weekly monthly]
+          description: "Minute interval for intraday data. Omit for daily data. " \
+                       "Values: 1 (1-min), 5 (5-min), 15 (15-min), 25 (25-min), 60 (1-hour)",
+          enum: %w[1 5 15 25 60]
         ),
         from_date: Ollama::Tool::Function::Parameters::Property.new(
           type: "string",
@@ -92,10 +98,15 @@ historical_data_tool = Ollama::Tool.new(
         ),
         to_date: Ollama::Tool::Function::Parameters::Property.new(
           type: "string",
-          description: "End date (YYYY-MM-DD format)"
+          description: "End date (YYYY-MM-DD format, non-inclusive)"
+        ),
+        calculate_indicators: Ollama::Tool::Function::Parameters::Property.new(
+          type: "boolean",
+          description: "If true, returns technical indicators instead of raw data. " \
+                       "Reduces response size and provides ready-to-use indicator values."
         )
       },
-      required: %w[symbol exchange_segment]
+      required: %w[symbol exchange_segment from_date to_date]
     )
   )
 )
@@ -249,9 +260,11 @@ begin
         puts "  ✅ Instrument found and quote retrieved"
         quote = result[:result][:quote]
         if quote
+          ohlc = quote[:ohlc]
           puts "  📊 Last Price: #{quote[:last_price]}"
           puts "  📊 Volume: #{quote[:volume]}"
-          puts "  📊 OHLC: O=#{quote[:ohlc][:open]}, H=#{quote[:ohlc][:high]}, L=#{quote[:ohlc][:low]}, C=#{quote[:ohlc][:close]}"
+          puts "  📊 OHLC: O=#{ohlc[:open]}, H=#{ohlc[:high]}, " \
+               "L=#{ohlc[:low]}, C=#{ohlc[:close]}"
         end
       end
     rescue StandardError => e
@@ -271,6 +284,81 @@ rescue Ollama::Error => e
   puts "   Message: #{e.message}"
 end
 
+puts "\n--- Test 5: Historical Data with Technical Indicators ---"
+puts "Request: Get NIFTY intraday data with technical indicators\n"
+
+begin
+  response = client.chat_raw(
+    model: "llama3.1:8b",
+    messages: [Ollama::Agent::Messages.user(
+      "Get intraday historical data for NIFTY with technical indicators for the last 30 days"
+    )],
+    tools: historical_data_tool,
+    allow_chat: true
+  )
+
+  tool_calls = response.message&.tool_calls
+  if tool_calls && !tool_calls.empty?
+    puts "✅ Tool call received"
+    call = tool_calls.first
+    puts "  Tool: #{call.name}"
+    puts "  Arguments: #{call.arguments.inspect}\n"
+
+    args = call.arguments
+    puts "  Expected parameters:"
+    puts "    - symbol: #{args['symbol'] || args[:symbol]}"
+    puts "    - exchange_segment: #{args['exchange_segment'] || args[:exchange_segment]}"
+    puts "    - interval: #{args['interval'] || args[:interval]} (for intraday)"
+    puts "    - from_date: #{args['from_date'] || args[:from_date]}"
+    puts "    - to_date: #{args['to_date'] || args[:to_date]}"
+    puts "    - calculate_indicators: #{args['calculate_indicators'] || args[:calculate_indicators]}"
+  else
+    puts "⚠️  No tool calls detected"
+    puts "Content: #{response.message&.content}\n"
+  end
+rescue Ollama::Error => e
+  puts "❌ Error: #{e.class.name}"
+  puts "   Message: #{e.message}"
+end
+
+puts "\n--- Test 6: Intraday Data with 5-minute intervals ---"
+puts "Request: Get NIFTY 5-minute intraday data for today\n"
+
+begin
+  today = Date.today.strftime("%Y-%m-%d")
+  response = client.chat_raw(
+    model: "llama3.1:8b",
+    messages: [Ollama::Agent::Messages.user(
+      "Get NIFTY intraday data with 5-minute intervals for today (#{today})"
+    )],
+    tools: historical_data_tool,
+    allow_chat: true
+  )
+
+  tool_calls = response.message&.tool_calls
+  if tool_calls && !tool_calls.empty?
+    puts "✅ Tool call received"
+    call = tool_calls.first
+    args = call.arguments
+
+    puts "  Verifying intraday parameters:"
+    interval = args["interval"] || args[:interval]
+    if %w[1 5 15 25 60].include?(interval.to_s)
+      puts "    ✅ Interval: #{interval} (valid intraday value)"
+    else
+      puts "    ❌ Interval: #{interval} (should be one of: 1, 5, 15, 25, 60)"
+    end
+
+    from_date = args["from_date"] || args[:from_date]
+    to_date = args["to_date"] || args[:to_date]
+    puts "    Date range: #{from_date} to #{to_date}"
+  else
+    puts "⚠️  No tool calls detected"
+  end
+rescue Ollama::Error => e
+  puts "❌ Error: #{e.message}"
+end
+
 puts "\n--- Summary ---"
 puts "✅ Use chat_raw() for tool calling - gives access to tool_calls"
 puts "⚠️  Use chat() only for simple content responses (no tool_calls needed)"
@@ -279,4 +367,9 @@ puts "   1. LLM requests tool via chat_raw() → get tool_calls"
 puts "   2. Find instrument using exchange_segment + symbol"
 puts "   3. Execute tool with instrument"
 puts "   4. Feed result back to LLM (if using Executor)"
+puts "\n📊 Historical Data enhancements:"
+puts "   - Use interval (1, 5, 15, 25, 60) for intraday data"
+puts "   - Omit interval for daily data"
+puts "   - Use calculate_indicators: true for technical indicators (RSI, MACD, etc.)"
+puts "   - Reduces response size and provides ready-to-use indicator values"
 puts "\n=== DONE ===\n"

data/lib/ollama/agent/executor.rb

@@ -180,34 +180,10 @@ module Ollama
 
       def invoke_tool(callable, args_hash)
         sym_args = normalize_parameter_names(args_hash)
+        keyword_result = call_with_keywords(callable, sym_args)
+        return keyword_result[:value] if keyword_result[:success]
 
-        # Try keyword invocation first (common for Ruby tools).
-        begin
-          callable.call(**sym_args)
-        rescue ArgumentError => e
-          # If the error indicates required keyword arguments, try parameter aliases.
-          if e.message.include?("required keyword") || e.message.include?("missing keyword")
-            aliased_args = apply_parameter_aliases(sym_args, callable)
-            if aliased_args != sym_args
-              begin
-                return callable.call(**aliased_args)
-              rescue ArgumentError
-                # Aliases didn't help, continue to try positional
-              end
-            end
-          end
-
-          # Try positional hash for callables that accept a hash argument.
-          # This handles cases where tools are defined as `lambda { |h| ... }` instead of keyword args.
-          begin
-            callable.call(args_hash)
-          rescue ArgumentError => positional_error
-            # If both keyword and positional fail, re-raise with context.
-            raise ArgumentError,
-                  "Tool invocation failed: #{positional_error.message}. Arguments provided: #{args_hash.inspect}. " \
-                  "Ensure the tool call includes all required parameters."
-          end
-        end
+        call_with_positional(callable, args_hash)
       end
 
       def normalize_parameter_names(args_hash)
@@ -234,6 +210,33 @@ module Ollama
         aliased
       end
 
+      def call_with_keywords(callable, sym_args)
+        { success: true, value: callable.call(**sym_args) }
+      rescue ArgumentError => e
+        return { success: false } unless missing_keyword_error?(e)
+
+        aliased_args = apply_parameter_aliases(sym_args, callable)
+        return { success: false } if aliased_args == sym_args
+
+        begin
+          { success: true, value: callable.call(**aliased_args) }
+        rescue ArgumentError
+          { success: false }
+        end
+      end
+
+      def call_with_positional(callable, args_hash)
+        callable.call(args_hash)
+      rescue ArgumentError => e
+        raise ArgumentError,
+              "Tool invocation failed: #{e.message}. Arguments provided: #{args_hash.inspect}. " \
+              "Ensure the tool call includes all required parameters."
+      end
+
+      def missing_keyword_error?(error)
+        error.message.include?("required keyword") || error.message.include?("missing keyword")
+      end
+
       def encode_tool_result(result)
         return result if result.is_a?(String)
 
@@ -248,9 +251,6 @@ module Ollama
           tool_entry
         when Hash
           tool_entry[:callable] || tool_entry["callable"]
-        else
-          # Tool objects are schema definitions only, not callables
-          nil
         end
       end
     end