Class: DecisionAgent::Simulation::ScenarioEngine

Inherits:
Object
  • Object
show all
Defined in:
lib/decision_agent/simulation/scenario_engine.rb

Overview

Engine for managing and executing test scenarios

Defined Under Namespace

Classes: ProgressTracker

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(agent:, version_manager: nil) ⇒ ScenarioEngine

Returns a new instance of ScenarioEngine.



11
12
13
14
 
# File 'lib/decision_agent/simulation/scenario_engine.rb', line 11

def initialize(agent:, version_manager: nil)
  @agent = agent
  @version_manager = version_manager || Versioning::VersionManager.new
end

Instance Attribute Details

#agent ⇒ Object (readonly)

Returns the value of attribute agent.



9
10
11
 
# File 'lib/decision_agent/simulation/scenario_engine.rb', line 9

def agent
  @agent
end

#version_manager ⇒ Object (readonly)

Returns the value of attribute version_manager.



9
10
11
 
# File 'lib/decision_agent/simulation/scenario_engine.rb', line 9

def version_manager
  @version_manager
end

Instance Method Details

#compare_versions(scenarios:, versions:, options: {}) ⇒ Hash

Compare scenarios across different rule versions

Parameters:

  • scenarios (Array<Hash>) —

    Scenarios to test

  • versions (Array<String, Integer, Hash>) —

    Rule versions to compare

  • options (Hash) (defaults to: {}) —

    Execution options

Returns:

  • (Hash) —

    Comparison results



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/decision_agent/simulation/scenario_engine.rb', line 118

def compare_versions(scenarios:, versions:, options: {})
  options = {
    parallel: true,
    thread_count: 4
  }.merge(options)

  version_results = {}
  versions.each do |version|
    results = execute_batch(scenarios: scenarios, rule_version: version, options: options)
    version_id = version.is_a?(Hash) ? (version[:id] || version["id"]) : version
    version_results[version_id.to_s] = results
  end

  {
    scenarios: scenarios,
    versions: versions.map { |v| v.is_a?(Hash) ? (v[:id] || v["id"]) : v },
    results_by_version: version_results,
    comparison: build_version_comparison(version_results)
  }
end

#execute(scenario:, rule_version: nil) ⇒ Hash

Execute a single scenario

Parameters:

  • scenario (Hash) —

    Scenario definition with context and optional metadata

  • rule_version (String, Integer, Hash, nil) (defaults to: nil) —

    Optional rule version to use

Returns:

  • (Hash) —

    Scenario execution result



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/decision_agent/simulation/scenario_engine.rb', line 20

def execute(scenario:, rule_version: nil)
  context = scenario[:context] || scenario["context"] || scenario
  metadata = scenario[:metadata] || scenario["metadata"] || {}

  analysis_agent = build_agent_from_version(rule_version) if rule_version
  analysis_agent ||= @agent

  ctx = context.is_a?(Context) ? context : Context.new(context)
  decision = analysis_agent.decide(context: ctx)

  {
    scenario_id: scenario[:id] || scenario["id"] || generate_scenario_id,
    context: ctx.to_h,
    decision: decision.decision,
    confidence: decision.confidence,
    explanations: decision.explanations,
    metadata: metadata,
    executed_at: Time.now.utc.iso8601
  }
end

#execute_batch(scenarios:, rule_version: nil, options: {}) ⇒ Hash

Execute multiple scenarios

Parameters:

  • scenarios (Array<Hash>) —

    Array of scenario definitions

  • rule_version (String, Integer, Hash, nil) (defaults to: nil) —

    Optional rule version

  • options (Hash) (defaults to: {}) —

    Execution options

    • :parallel [Boolean] Use parallel execution (default: true)
    • :thread_count [Integer] Number of threads (default: 4)
    • :progress_callback [Proc] Progress callback

Returns:

  • (Hash) —

    Batch execution results



49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/decision_agent/simulation/scenario_engine.rb', line 49

def execute_batch(scenarios:, rule_version: nil, options: {})
  options = {
    parallel: true,
    thread_count: 4,
    progress_callback: nil
  }.merge(options)

  analysis_agent = build_agent_from_version(rule_version) if rule_version
  analysis_agent ||= @agent

  results = execute_scenarios_with_progress(
    scenarios, analysis_agent, rule_version, options
  )

  build_batch_report(results)
end

#execute_scenarios_with_progress(scenarios, analysis_agent, rule_version, options) ⇒ Object 



66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/decision_agent/simulation/scenario_engine.rb', line 66

def execute_scenarios_with_progress(scenarios, analysis_agent, rule_version, options)
  results = []
  mutex = Mutex.new
  progress_tracker = ProgressTracker.new(scenarios.size, options[:progress_callback])

  if options[:parallel] && scenarios.size > 1
    execute_parallel(scenarios, analysis_agent, options, mutex) do |result|
      mutex.synchronize do
        results << result
        progress_tracker.increment
      end
    end
  else
    execute_sequential(scenarios, rule_version, results, progress_tracker)
  end

  results
end

#execute_sequential(scenarios, rule_version, results, progress_tracker) ⇒ Object 



85
86
87
88
89
90
91
 
# File 'lib/decision_agent/simulation/scenario_engine.rb', line 85

def execute_sequential(scenarios, rule_version, results, progress_tracker)
  scenarios.each_with_index do |scenario, _index|
    result = execute(scenario: scenario, rule_version: rule_version)
    results << result
    progress_tracker.increment
  end
end