class Riffer::Agent

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

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

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

# File lib/riffer/agent.rb, line 185
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 209
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 64
def self.instructions(instructions_or_proc = nil)
  return @instructions if instructions_or_proc.nil?

  if instructions_or_proc.is_a?(Proc)
    @instructions = instructions_or_proc
  else
    validate_is_string!(instructions_or_proc, "instructions")
    @instructions = instructions_or_proc
  end
end

# File lib/riffer/agent.rb, line 114
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 86
def self.model_options(options = nil)
  return @model_options || {} if options.nil?
  @model_options = options
end

# File lib/riffer/agent.rb, line 226
def initialize
  @messages = []
  @message_callbacks = []
  @token_usage = nil
  @interrupted = false
  @model_config = self.class.model
  @instructions_config = 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 78
def self.provider_options(options = nil)
  return @provider_options || {} if options.nil?
  @provider_options = options
end

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

# File lib/riffer/agent.rb, line 96
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 136
def self.tool_runtime(value = nil)
  if value.nil?
    return @tool_runtime if instance_variable_defined?(:@tool_runtime)
    superclass.respond_to?(:tool_runtime) ? superclass.tool_runtime : nil
  else
    @tool_runtime = value
  end
end

# File lib/riffer/agent.rb, line 122
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 245
def generate(prompt_or_messages, files: nil, context: nil)
  @context = context
  prepare_run
  @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 334
def interrupt!(reason = nil)
  throw :riffer_interrupt, reason
end

# File lib/riffer/agent.rb, line 322
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 296
def resume(messages: nil, context: nil)
  restore_state(messages: messages, context: context)
  @structured_output = resolve_structured_output
  run_generate_loop(resume: true)
end

# File lib/riffer/agent.rb, line 307
def resume_stream(messages: nil, context: nil)
  raise Riffer::ArgumentError, "Structured output is not supported with streaming. Use #resume instead." if self.class.structured_output

  restore_state(messages: messages, context: context)

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

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

  @context = context
  prepare_run
  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