class Riffer::Agent

# File lib/riffer/agent.rb, line 122
def self.all
  subclasses
end

# File lib/riffer/agent.rb, line 115
def self.find(identifier)
  subclasses.find { |agent_class| agent_class.identifier == identifier.to_s }
end

# File lib/riffer/agent.rb, line 131
def self.generate(...)
  new.generate(...)
end

# File lib/riffer/agent.rb, line 152
def self.guardrail(phase, with:, **options)
  valid_phases = [*Riffer::Guardrails::PHASES, :around]
  raise Riffer::ArgumentError, "Invalid guardrail phase: #{phase}" unless valid_phases.include?(phase)
  raise Riffer::ArgumentError, "Guardrail must be a Riffer::Guardrail subclass" unless with.is_a?(Class) && with <= Riffer::Guardrail

  @guardrails ||= {before: [], after: []}
  config = {class: with, options: options}

  case phase
  when :before
    @guardrails[:before] << config
  when :after
    @guardrails[:after] << config
  when :around
    @guardrails[:before] << config
    @guardrails[:after] << config
  end
end

# File lib/riffer/agent.rb, line 176
def self.guardrails_for(phase)
  @guardrails ||= {before: [], after: []}
  @guardrails[phase] || []
end

# File lib/riffer/agent.rb, line 32
def self.identifier(value = nil)
  return @identifier || class_name_to_path(name) if value.nil?
  @identifier = value.to_s
end

# File lib/riffer/agent.rb, line 54
def self.instructions(instructions_text = nil)
  return @instructions if instructions_text.nil?
  validate_is_string!(instructions_text, "instructions")
  @instructions = instructions_text
end

# File lib/riffer/agent.rb, line 99
def self.max_steps(value = nil)
  return @max_steps || DEFAULT_MAX_STEPS if value.nil?
  @max_steps = value
end

# File lib/riffer/agent.rb, line 40
def self.model(model_string_or_proc = nil)
  return @model if model_string_or_proc.nil?

  if model_string_or_proc.is_a?(Proc)
    @model = model_string_or_proc
  else
    validate_is_string!(model_string_or_proc, "model")
    @model = model_string_or_proc
  end
end

# File lib/riffer/agent.rb, line 71
def self.model_options(options = nil)
  return @model_options || {} if options.nil?
  @model_options = options
end

# File lib/riffer/agent.rb, line 193
def initialize
  @messages = []
  @message_callbacks = []
  @token_usage = nil
  @interrupted = false
  @model_config = self.class.model
  @instructions_text = self.class.instructions

  if @model_config.is_a?(Proc)
    @provider_name = nil
    @model_name = nil
  else
    parse_model_string!(@model_config)
  end
end

# File lib/riffer/agent.rb, line 63
def self.provider_options(options = nil)
  return @provider_options || {} if options.nil?
  @provider_options = options
end

# File lib/riffer/agent.rb, line 140
def self.stream(...)
  new.stream(...)
end

# File lib/riffer/agent.rb, line 81
def self.structured_output(params = nil, &block)
  if block
    @structured_output = Riffer::Params.new
    @structured_output.instance_eval(&block)
  elsif params.nil?
    @structured_output
  else
    raise Riffer::ArgumentError, "structured_output must be a Riffer::Params" unless params.is_a?(Riffer::Params)
    @structured_output = params
  end
end

# File lib/riffer/agent.rb, line 107
def self.uses_tools(tools_or_lambda = nil)
  return @tools_config if tools_or_lambda.nil?
  @tools_config = tools_or_lambda
end

# File lib/riffer/agent.rb, line 212
def generate(prompt_or_messages, files: nil, tool_context: nil)
  @tool_context = tool_context
  @resolved_tools = nil
  clear_resolved_model
  @interrupted = false
  @structured_output = resolve_structured_output
  initialize_messages(prompt_or_messages, files: files)

  all_modifications = [] #: Array[Riffer::Guardrails::Modification]

  tripwire, modifications = run_before_guardrails
  all_modifications.concat(modifications)
  return build_response("", tripwire: tripwire, modifications: all_modifications) if tripwire

  run_generate_loop(all_modifications)
end

# File lib/riffer/agent.rb, line 288
def on_message(&block)
  raise Riffer::ArgumentError, "on_message requires a block" unless block_given?
  @message_callbacks << block
  self
end

# File lib/riffer/agent.rb, line 265
def resume(messages: nil, tool_context: nil)
  restore_state(messages: messages, tool_context: tool_context)
  run_generate_loop(resume: true)
end

# File lib/riffer/agent.rb, line 275
def resume_stream(messages: nil, tool_context: nil)
  restore_state(messages: messages, tool_context: tool_context)

  Enumerator.new do |yielder|
    run_stream_loop(yielder, resume: true)
  end
end

# File lib/riffer/agent.rb, line 234
def stream(prompt_or_messages, files: nil, tool_context: nil)
  raise Riffer::ArgumentError, "Structured output is not supported with streaming. Use #generate instead." if self.class.structured_output

  @tool_context = tool_context
  @resolved_tools = nil
  clear_resolved_model
  @interrupted = false
  initialize_messages(prompt_or_messages, files: files)

  Enumerator.new do |yielder|
    tripwire, modifications = run_before_guardrails
    modifications.each { |m| yielder << Riffer::StreamEvents::GuardrailModification.new(m) }

    if tripwire
      yielder << Riffer::StreamEvents::GuardrailTripwire.new(tripwire)
      next
    end

    run_stream_loop(yielder)
  end
end