Soka

gem 'soka'

require 'soka'

# Create a simple time tool
class TimeTool < Soka::AgentTool
  desc "Get current time"

  def call
    Time.now.strftime('%Y-%m-%d %H:%M:%S')
  end
end

# Create Agent
class SimpleAgent < Soka::Agent
  tool TimeTool
end

# Execute
agent = SimpleAgent.new
result = agent.run("What time is it?")
puts result.final_answer

# Gemfile
gem 'soka-rails'

# app/soka/agents/customer_support_agent.rb
class CustomerSupportAgent < ApplicationAgent
  tool OrderLookupTool
  tool UserInfoTool
end

# app/controllers/conversations_controller.rb
class ConversationsController < ApplicationController
  def create
    agent = CustomerSupportAgent.new
    result = agent.run(params[:message])

    render json: {
      answer: result.final_answer,
      status: result.status
    }
  end
end

Soka.setup do |config|
  # AI Configuration
  config.ai do |ai|
    ai.provider = :gemini  # :gemini, :openai, :anthropic
    ai.model = 'gemini-2.5-flash-lite'
    ai.api_key = ENV['GEMINI_API_KEY']
  end

  # Performance Configuration
  config.performance do |perf|
    perf.max_iterations = 10      # ReAct max iterations
  end

  # Default tools
  config.tools = [SearchTool, TimeTool]
end

class SearchTool < Soka::AgentTool
  desc "Search the web for information"

  params do
    requires :query, String, desc: "The query to search for"
    optional :location, String, desc: "Location context", default: "Global"

    # Parameter validation
    validates :query, presence: true, length: { minimum: 1, maximum: 500 }
    validates :location, inclusion: { in: %w[Global US Europe Asia] }, allow_nil: true
  end

  def call(query:, location: "Global")
    # Actual search logic
    perform_search(query, location)
  rescue => e
    { error: e.message, tool: self.class.name }
  end

  private

  def perform_search(query, location)
    # Here you can call real search APIs
    "Search results for #{query} in #{location}..."
  end
end

class WeatherAgent < Soka::Agent
  # AI settings (override global settings)
  provider :gemini
  model 'gemini-2.5-flash-lite'
  max_iterations 10

  # Register tools
  tool SearchTool
  tool TimeTool

  # Conditional tool registration
  tool CalculatorTool, if: -> { ENV['ENABLE_CALCULATOR'] == 'true' }

  # Batch registration
  tools SearchTool, TimeTool, WeatherTool

  # Custom tool (functional) - requires description as second parameter
  tool :get_weather, "Get weather for a location"

  # Custom instructions (optional)
  instructions "You are a weather expert. Provide detailed weather information."

  # Thinking language (optional)
  think_in 'en'  # Default is 'en'

  # Lifecycle hooks
  before_action :track_action
  after_action :update_metrics
  on_error :handle_error

  private

  # Method implementation for functional tool
  # Note: This is currently experimental and not fully implemented
  def get_weather(location:)
    "#{location} is currently sunny, temperature 25°C"
  end

  def track_action(action)
    # Track action execution
    @action_count ||= 0
    @action_count += 1
  end

  def update_metrics(result)
    # Update metrics
    # metrics.record(result)
  end

  def handle_error(error, context)
    # Handle errors
    :continue  # or :stop to interrupt execution
  end
end

agent = WeatherAgent.new

agent.run('What is the weather in Tokyo today?') do |event|
  case event.type
  when :thought
    puts "💭 Thinking: #{event.content}"
  when :action
    puts "🔧 Action: Using tool #{event.content[:tool]}"
  when :observation
    puts "👀 Observation: #{event.content}"
  when :final_answer
    puts "✅ Answer: #{event.content}"
  when :error
    puts "❌ Error: #{event.content}"
  end
end

agent = WeatherAgent.new
result = agent.run('What is the weather in Tokyo today?')

# Result object provides rich information
puts result.final_answer      # Final answer
puts result.iterations       # Number of iterations used
puts result.status          # :success, :failed, :max_iterations_reached
puts result.execution_time  # Execution time (if recorded)

# Check execution status
if result.successful?
  puts "Success: #{result.final_answer}"
elsif result.failed?
  puts "Failed: #{result.error}"
elsif result.max_iterations_reached?
  puts "Max iterations reached"
end

# Initialize Agent with history
memory = [
  { role: 'user', content: 'My name is John' },
  { role: 'assistant', content: 'Hello John! Nice to meet you.' }
]

agent = WeatherAgent.new(memory: memory)
result = agent.run('What is my name?')
# => "Your name is John."

# Memory updates automatically
puts agent.memory
# <Soka::Memory> [
#   { role: 'user', content: 'My name is John' },
#   { role: 'assistant', content: 'Hello John! Nice to meet you.' },
#   { role: 'user', content: 'What is my name?' },
#   { role: 'assistant', content: 'Your name is John.' }
# ]

# View complete thought process
puts agent.thoughts_memory
# <Soka::ThoughtsMemory> (3 sessions, 2 successful, 1 failed, avg iterations: 2.3)

# Get detailed information for specific session
last_session = agent.thoughts_memory.last_session
puts last_session[:thoughts]  # All thinking steps
puts last_session[:final_answer]  # Final answer for that execution

class FriendlyAgent < Soka::Agent
  provider :gemini

  # Method 1: Static string instructions
  instructions <<~PROMPT
    You are a friendly, helpful assistant.
    Use casual language and be encouraging.
    Add emojis when appropriate.
  PROMPT
end

# Method 2: Dynamic instructions using method
class DynamicAgent < Soka::Agent
  provider :gemini

  # Reference a method for dynamic instructions
  instructions :generate_instructions

  private

  def generate_instructions
    hour = Time.now.hour
    mood = hour < 12 ? 'cheerful morning' : 'relaxed afternoon'

    <<~PROMPT
      You are a #{mood} assistant.
      Current Time: #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}
      Adjust your tone based on the time of day.
    PROMPT
  end
end

# Method 3: Override at runtime
agent = FriendlyAgent.new(
  instructions: 'Be more formal and professional.'
)
result = agent.run("Help me with this task")

class GlobalAgent < Soka::Agent
  provider :gemini

  # Set default thinking language
  think_in 'zh-TW'  # Think in Traditional Chinese
end

# Or set dynamically
agent = GlobalAgent.new(think_in: 'ja-JP')
result = agent.run("幫我解決這個問題")  # Input in Chinese
# Agent thinks in Japanese internally, responds in Chinese

# Result object attributes
result.input            # User input
result.thoughts         # Array of thinking steps
result.final_answer     # Final answer
result.status          # Status (:success, :failed, :max_iterations_reached)
result.error           # Error message (if any)
result.execution_time  # Execution time (seconds)
result.iterations      # Number of iterations

# Complete structure
{
  input: "User input",
  thoughts: [
    {
      step: 1,
      thought: "Thinking content",
      action: { tool: "search", params: { query: "..." } },
      observation: "Observation result"
    }
  ],
  final_answer: "Final answer",
  status: :success,        # :success, :failed, :max_iterations_reached
  error: nil,             # Error message (if any)
  execution_time: 1.23,   # Execution time (seconds)
  iterations: 2,          # Number of iterations
  created_at: Time        # Creation time
}

RSpec.describe WeatherAgent do
  include Soka::TestHelpers

  it "answers weather questions" do
    # Mock AI response
    mock_ai_response({
      thoughts: [
        {
          step: 1,
          thought: "Need to search for weather information",
          action: { tool: "search", params: { query: "Tokyo weather" } },
          observation: "Tokyo is sunny today"
        }
      ],
      final_answer: "Tokyo is sunny today."
    })

    # Mock tool response
    mock_tool_response(SearchTool, "Tokyo is sunny today")

    agent = described_class.new
    result = agent.run("What's the weather in Tokyo?")

    expect(result).to be_successful
    expect(result.final_answer).to include("sunny")
    expect(result).to have_thoughts_count(1)
    expect(result.status).to eq(:success)
  end

  it "handles tool errors gracefully" do
    allow_tool_to_fail(SearchTool, StandardError.new("API error"))

    agent = described_class.new
    result = agent.run("Search test")

    expect(result).to be_failed
    expect(result.error).to include("API error")
  end
end

class CustomEngine < Soka::Engines::Base
  def reason(task, &block)
    # Implement custom reasoning logic
    context = Soka::Engines::ReasoningContext.new(
      task: task,
      event_handler: block,
      max_iterations: max_iterations
    )

    # Use emit_event to send events
    emit_event(:thought, "Starting reasoning...", &block)

    # Perform reasoning...

    # Return result (using Struct)
    Soka::Engines::React::ReasonResult.new(
      input: task,
      thoughts: thoughts,
      final_answer: answer,
      status: :success
    )
  end
end

# Use custom engine
agent = MyAgent.new(engine: CustomEngine)

# Adjust max iterations
Soka.configure do |c|
  c.performance.max_iterations = 20
end

# Use block mode to see execution process
agent.run(query) do |event|
  p event  # Print all events
end

# Inspect thought process
result = agent.run(query)
result.thoughts.each do |thought|
  puts "Step #{thought[:step]}: #{thought[:thought]}"
  puts "Action: #{thought[:action]}" if thought[:action]
  puts "Observation: #{thought[:observation]}" if thought[:observation]
end