pub struct ConstraintMetricSymbol[T, S] {
  key : String
  comparator : MetricComparator
  value : Double
  source : ConstraintSource
  read : (ImprovementCandidate[T], Int, S) -> Result[Double, String]
}

pub enum ConstraintSource {
  Absolute
  Delta
  Ratio
  DeltaRatio
}

pub struct EvalBudgetPatch {
  max_steps : Int?
  max_sub_calls : Int?
  max_depth : Int?
  max_prompt_read_chars : Int?
}

pub struct EvalCase {
  id : String
  prompt : String
  query : String
  expected : String
  metric : EvalMetric
  tags : Array[String]
  budget : EvalBudgetPatch?
}

pub enum EvalMetric {
  Exact
  Contains
}

pub struct ImprovementCandidate[T] {
  id : String
  input : T
}

pub struct ImprovementConstraint {
  key : String
  comparator : MetricComparator
  value : Double
  source : ConstraintSource
}

pub struct ImprovementContext[T] {
  baseline : MetricSnapshot
  baseline_score : Double
  accepted : Array[ImprovementResult[T]]
  index : Int
}

pub struct ImprovementObjective {
  key : String
  direction : MetricDirection
  weight : Double
}

pub struct ImprovementPolicy {
  objectives : Array[ImprovementObjective]
  constraints : Array[ImprovementConstraint]
  min_score_delta : Double
}

pub struct ImprovementReport[T] {
  policy : ImprovementPolicy
  baseline : MetricSnapshot
  baseline_score : Double
  results : Array[ImprovementResult[T]]
  best_accepted : ImprovementResult[T]?
}

pub struct ImprovementResult[T] {
  candidate : ImprovementCandidate[T]
  accepted : Bool
  reasons : Array[String]
  snapshot : MetricSnapshot?
  score : Double?
  score_delta : Double?
  error : String?
}

pub struct LongRunImprovementReport[T, S] {
  rounds : Array[ImprovementReport[T]]
  accepted_history : Array[ImprovementResult[T]]
  final_baseline : MetricSnapshot
  final_baseline_score : Double
  final_state : S
}

pub struct LongRunIterationContext[T, S] {
  iteration : Int
  state : S
  baseline : MetricSnapshot
  baseline_score : Double
  rounds : Array[ImprovementReport[T]]
  accepted_history : Array[ImprovementResult[T]]
}

pub enum MetricComparator {
  Lt
  Lte
  Gt
  Gte
  Eq
}

pub enum MetricDirection {
  Maximize
  Minimize
}

pub struct MetricSnapshot {
  metrics : Map[String, Double]
  gates : Map[String, Bool]
}

pub struct ObjectiveMetricSymbol[T, S] {
  key : String
  direction : MetricDirection
  weight : Double
  read : (ImprovementCandidate[T], Int, S) -> Result[Double, String]
}

pub struct PlannedLongRunHooks[T, S] {
  baseline : MetricSnapshot
  initial_state : S
  max_iterations : Int?
  stop_when_no_accept : Bool?
  generate_candidates : (LongRunIterationContext[T, S], RLMPlannerPlan) -> Array[ImprovementCandidate[T]]
  evaluate : (ImprovementCandidate[T], LongRunIterationContext[T, S], RLMPlannerPlan) -> Result[MetricSnapshot, String]
  on_accepted : (ImprovementResult[T], S) -> S?
}

pub enum PlannedRLMResult[T, S] {
  SingleResult(RLMPlannerPlan, RLMResultPack)
  LongRunResult(RLMPlannerPlan, LongRunImprovementReport[T, S])
}

pub struct PlannerConstraintSpec {
  key : String
  comparator : MetricComparator
  value : Double
  source : ConstraintSource
}

pub struct PlannerLongRunSpec {
  objectives : Array[PlannerObjectiveSpec]
  constraints : Array[PlannerConstraintSpec]
  max_iterations : Int?
  stop_when_no_accept : Bool?
  min_score_delta : Double?
}

pub struct PlannerObjectiveSpec {
  key : String
  direction : MetricDirection
  weight : Double
}

pub enum ProgramMode {
  Single
  LongRun
}

pub struct ProgramPlan {
  mode : ProgramMode
  candidate_limit : Int
  max_iterations : Int
  stop_when_no_accept : Bool
}

pub struct ProgramResult[T, S] {
  plan : ProgramPlan
  run : ProgramRun[T, S]
  logs : Array[String]
}

pub enum ProgramRun[T, S] {
  SingleRun(ImprovementReport[T])
  LongRunRun(LongRunImprovementReport[T, S])
}

pub struct RLMBudgetPatch {
  max_steps : Int?
  max_sub_calls : Int?
  max_depth : Int?
  max_prompt_read_chars : Int?
}

pub struct RLMBudgetState {
  max_steps : Int
  max_sub_calls : Int
  max_depth : Int
  max_prompt_read_chars : Int
  steps_used : Int
  sub_calls_used : Int
  depth : Int
  prompt_read_chars_used : Int
}

pub struct RLMChatMessage {
  role : RLMRole
  content : String
}

pub enum RLMDSL {
  PromptMeta
  DocParse(String?, String?, String)
  DocSelectSection(String, String, String)
  DocTableSum(String, Json, String)
  DocSelectRows(String, Json, String?, Json?, String)
  DocProjectColumns(String, Array[Json], String, String?, Bool?)
  SlicePrompt(Int, Int, String)
  Find(String, Int, String)
  ChunkNewlines(Int, String)
  ChunkTokens(Int, Int?, String)
  SumCsvColumn(Int, String?, String)
  PickWord(Int?, String)
  CallSymbol(String, String, Json?, Json?)
  SubMap(String, String, String, Int?, Int?)
  ReduceJoin(String, String, String)
  Set(String, Json)
  Finalize(String)
}

pub struct RLMExternalSymbolCall {
  symbol : String
  prompt : String
  prompt_id : String
  depth : Int
  args : Json?
  input : Json?
}

pub struct RLMOpenAIOptions {
  model : String
  max_tokens : Int
  system_prompt : String
  timeout_sec : Int
  max_retries : Int
}

pub struct RLMPlannerPlan {
  kind : String
  version : Int
  mode : ProgramMode
  task : String
  profile : RLMProfile?
  budget : RLMBudgetPatch?
  require_prompt_read_before_finalize : Bool?
  symbols : Array[String]
  long_run : PlannerLongRunSpec?
}

pub enum RLMProfile {
  Pure
  Hybrid
}

pub struct RLMPromptMeta {
  prompt_id : String
  length : Int
  preview_head : String
}

pub struct RLMReplExecTrace {
  step : Int
  op : String
  stdout : String
  stdout_meta : RLMStdoutMeta
}

pub struct RLMResultPack {
  final_output : String
  trace : Array[RLMTraceEvent]
  budget : RLMBudgetState
}

pub enum RLMRole {
  System
  User
  Assistant
}

pub struct RLMRootStepTrace {
  step : Int
  prompt_meta : RLMPromptMeta
  stdout_meta : RLMStdoutMeta
}

pub struct RLMRunOptions {
  budget : RLMBudgetState
  meta_preview_chars : Int
  task : String?
  require_prompt_read_before_finalize : Bool
  sub_runner : (String) -> Result[String, String]?
  symbol_runner : (RLMExternalSymbolCall) -> Result[Json, String]?
}

pub struct RLMStdoutMeta {
  length : Int
  preview : String
  keys : Array[String]
}

pub struct RLMSubCallTrace {
  depth : Int
  query : String
  result_meta : RLMStdoutMeta
  cached : Bool
}

pub enum RLMTraceEvent {
  RootStep(RLMRootStepTrace)
  ReplExec(RLMReplExecTrace)
  SubCall(RLMSubCallTrace)
}

pub struct RoundSummary {
  result_ids : Array[String]
  accepted_count : Int
}

fn[T, S] build_policy_from_metric_symbols(objectives : Array[ObjectiveMetricSymbol[T, S]], constraints? : Array[ConstraintMetricSymbol[T, S]], min_score_delta? : Double) -> ImprovementPolicy

fn build_profile_rlm_options(profile : RLMProfile) -> RLMRunOptions

fn[T] candidate(id : String, input : T) -> ImprovementCandidate[T]

fn coerce_planner_plan_from_json(raw : Json, fallback_task : String, available_symbols : Array[String]) -> RLMPlannerPlan

fn[T, S] collect_metric_snapshot_by_symbols(candidate : ImprovementCandidate[T], iteration : Int, state : S, objectives : Array[ObjectiveMetricSymbol[T, S]], constraints? : Array[ConstraintMetricSymbol[T, S]]) -> Result[MetricSnapshot, String]

fn compile_plan_to_rlm_options(plan : RLMPlannerPlan, base? : RLMRunOptions?) -> RLMRunOptions

fn constraint(key : String, comparator : MetricComparator, value : Double, source? : ConstraintSource) -> ImprovementConstraint

fn[T, S] constraint_metric_symbol(key : String, comparator : MetricComparator, value : Double, read : (ImprovementCandidate[T], Int, S) -> Result[Double, String], source? : ConstraintSource) -> ConstraintMetricSymbol[T, S]

fn[T, TMetrics] create_metric_symbol(baseline_input : T, coerce_candidate : (Json) -> Result[T, String], evaluate_candidate : (T) -> Result[TMetrics, String], pick_metric : (TMetrics, String) -> Result[Double, String], cache : Map[String, TMetrics], cache_key : (T) -> String) -> ((RLMExternalSymbolCall) -> Result[Json, String])

fn create_plan_with_provider(input : String, prompt : String, provider : &
@mizchi/llm.Provider
Provider, available_symbols? : Array[String], planner_system_prompt? : String) -> RLMPlannerPlan

fn default_planner_system_prompt() -> String

fn default_rlm_budget(max_steps? : Int, max_sub_calls? : Int, max_depth? : Int, max_prompt_read_chars? : Int, depth? : Int) -> RLMBudgetState

fn default_rlm_openai_options(model? : String, max_tokens? : Int, system_prompt? : String, timeout_sec? : Int, max_retries? : Int) -> RLMOpenAIOptions

fn default_rlm_options(budget? : RLMBudgetState, meta_preview_chars? : Int, task? : String?, require_prompt_read_before_finalize? : Bool, sub_runner? : (String) -> Result[String, String]?, symbol_runner? : (RLMExternalSymbolCall) -> Result[Json, String]?) -> RLMRunOptions

fn dsl_call_symbol(symbol : String, out : String, args? : Json?, input? : Json?) -> RLMDSL

fn dsl_chunk_newlines(max_lines : Int, out : String) -> RLMDSL

fn dsl_chunk_tokens(max_tokens : Int, overlap? : Int?, out? : String) -> RLMDSL

fn dsl_doc_parse(format? : String?, delimiter? : String?, out? : String) -> RLMDSL

fn dsl_doc_project_columns(in_key : String, columns : Array[Json], out : String, separator? : String?, include_header? : Bool?) -> RLMDSL

fn dsl_doc_select_rows(in_key : String, column : Json, comparator? : String?, value? : Json?, out? : String) -> RLMDSL

fn dsl_doc_select_section(in_key : String, title : String, out : String) -> RLMDSL

fn dsl_doc_table_sum(in_key : String, column : Json, out : String) -> RLMDSL

fn dsl_finalize(from : String) -> RLMDSL

fn dsl_find(needle : String, from? : Int, out? : String) -> RLMDSL

fn dsl_pick_word(index? : Int?, out? : String) -> RLMDSL

fn dsl_prompt_meta() -> RLMDSL

fn dsl_reduce_join(in_key : String, sep : String, out : String) -> RLMDSL

fn dsl_set(path : String, value : Json) -> RLMDSL

fn dsl_set_string(path : String, value : String) -> RLMDSL

fn dsl_slice_prompt(start : Int, end : Int, out : String) -> RLMDSL

fn dsl_sub_map(in_key : String, query_template : String, out : String, limit? : Int?, concurrency? : Int?) -> RLMDSL

fn dsl_sum_csv_column(column : Int, delimiter? : String?, out? : String) -> RLMDSL

fn objective(key : String, direction : MetricDirection, weight? : Double) -> ImprovementObjective

fn[T, S] objective_metric_symbol(key : String, direction : MetricDirection, read : (ImprovementCandidate[T], Int, S) -> Result[Double, String], weight? : Double) -> ObjectiveMetricSymbol[T, S]

fn parse_eval_jsonl(input : String) -> Result[Array[EvalCase], String]

fn parse_rlm_profile(input : String?) -> Result[RLMProfile, String]

fn[T, S] planned_long_run_hooks(baseline : MetricSnapshot, initial_state : S, generate_candidates : (LongRunIterationContext[T, S], RLMPlannerPlan) -> Array[ImprovementCandidate[T]], evaluate : (ImprovementCandidate[T], LongRunIterationContext[T, S], RLMPlannerPlan) -> Result[MetricSnapshot, String], max_iterations? : Int?, stop_when_no_accept? : Bool?, on_accepted? : (ImprovementResult[T], S) -> S?) -> PlannedLongRunHooks[T, S]

fn planner_budget_patch(max_steps? : Int?, max_sub_calls? : Int?, max_depth? : Int?, max_prompt_read_chars? : Int?) -> RLMBudgetPatch

fn planner_constraint_spec(key : String, comparator : MetricComparator, value : Double, source? : ConstraintSource) -> PlannerConstraintSpec

fn planner_long_run_spec(objectives : Array[PlannerObjectiveSpec], constraints? : Array[PlannerConstraintSpec], max_iterations? : Int?, stop_when_no_accept? : Bool?, min_score_delta? : Double?) -> PlannerLongRunSpec

fn planner_objective_spec(key : String, direction : MetricDirection, weight? : Double) -> PlannerObjectiveSpec

fn planner_plan(mode : ProgramMode, task : String, profile? : RLMProfile?, budget? : RLMBudgetPatch?, require_prompt_read_before_finalize? : Bool?, symbols? : Array[String], long_run? : PlannerLongRunSpec?) -> RLMPlannerPlan

fn policy(objectives : Array[ImprovementObjective], constraints? : Array[ImprovementConstraint], min_score_delta? : Double) -> ImprovementPolicy

fn program_plan(mode : ProgramMode, candidate_limit : Int, max_iterations : Int, stop_when_no_accept? : Bool) -> ProgramPlan

fn round_summary(result_ids : Array[String], accepted_count : Int) -> RoundSummary

fn[T] run_improvement_loop(baseline : MetricSnapshot, policy : ImprovementPolicy, candidates : Array[ImprovementCandidate[T]], evaluate : (ImprovementCandidate[T], ImprovementContext[T]) -> Result[MetricSnapshot, String], update_baseline_on_accept? : Bool) -> ImprovementReport[T]

fn[T, S] run_long_improvement_loop(baseline : MetricSnapshot, policy : ImprovementPolicy, initial_state : S, max_iterations : Int, stop_when_no_accept : Bool, generate_candidates : (LongRunIterationContext[T, S]) -> Array[ImprovementCandidate[T]], evaluate : (ImprovementCandidate[T], LongRunIterationContext[T, S]) -> Result[MetricSnapshot, String], on_accepted : (ImprovementResult[T], S) -> S) -> LongRunImprovementReport[T, S]

fn[T, S] run_planned_rlm(prompt : String, complete : (Array[RLMChatMessage], Int) -> RLMDSL, plan : RLMPlannerPlan, runtime_options? : RLMRunOptions?, long_run? : PlannedLongRunHooks[T, S]?) -> Result[PlannedRLMResult[T, S], String]