self_agency 0.0.1

data/examples/12_autonomous_robots/main.rb

@@ -0,0 +1,166 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# 12_autonomous_robots/main.rb — Autonomous Robots Demo
+#
+# Demonstrates:
+#   - Three-layer LLM approach: decompose goal -> generate helpers -> generate orchestrator
+#   - Robots receive "what" not "how" — LLM decides method names, algorithms, data structures
+#   - Pipeline execution: collect landmarks -> analyze data -> plan itinerary
+#
+# Contrast with Demo 11:
+#   Demo 11 dictates method names and algorithms in the task description.
+#   Demo 12 gives only a high-level goal and lets the LLM decide everything.
+#
+# Requires a running Ollama instance with the configured model.
+
+require_relative "robot"
+
+# ---------------------------------------------------------------------------
+# Create message bus and autonomous robots
+# ---------------------------------------------------------------------------
+
+puts "=== Autonomous Robots — City Landmarks Tour Pipeline ==="
+puts ""
+
+bus = MessageBus.new
+
+collector = Robot.new(
+  name: "Collector",
+  goal: "Return an Array of 8 Hashes representing fictional city landmarks. " \
+        "Each Hash has Symbol keys :name (String), :type (String, e.g. 'museum'), " \
+        ":duration (Integer, 30..180 minutes), :rating (Float, 1.0..5.0). " \
+        "Do NOT wrap the Array in an outer Hash.",
+  bus: bus
+)
+
+puts ""
+
+analyst = Robot.new(
+  name: "Analyst",
+  goal: "Analyze landmark data. The input is an Array of Hashes, each with keys " \
+        ":name (String), :type (String), :duration (Integer), :rating (Float). " \
+        "Return a Hash with three keys: " \
+        ":statistics (a Hash with :avg_rating, :avg_duration, :total_duration, :count), " \
+        ":ranked (the landmarks Array sorted by :rating descending), " \
+        ":by_type (a Hash grouping landmarks by :type)",
+  bus: bus,
+  receives_input: true
+)
+
+puts ""
+
+planner = Robot.new(
+  name: "Planner",
+  goal: "Create a formatted one-day tour itinerary. The input is a Hash with keys " \
+        ":statistics, :ranked, and :by_type. " \
+        "Use :ranked (an Array of Hashes with :name, :type, :duration, :rating) " \
+        "to select top-rated landmarks that fit within 360 total minutes of visit time. " \
+        "Return a String with a formatted itinerary listing each stop with its name, " \
+        "type, duration, and rating",
+  bus: bus,
+  receives_input: true
+)
+
+# ---------------------------------------------------------------------------
+# Display capabilities and generated source
+# ---------------------------------------------------------------------------
+
+puts ""
+puts "=== Capabilities Summary ==="
+[collector, analyst, planner].each do |robot|
+  puts "#{robot.name}: #{robot.capabilities.inspect}"
+end
+
+puts ""
+puts "=== Generated Source Code ==="
+[collector, analyst, planner].each do |robot|
+  robot.generation_log.each do |entry|
+    puts "--- #{robot.name}##{entry[:method_name]} ---"
+    puts entry[:code]
+    puts ""
+  end
+end
+
+# ---------------------------------------------------------------------------
+# Execute the pipeline
+# ---------------------------------------------------------------------------
+
+puts "=== Executing Pipeline ==="
+puts ""
+
+# Step 1: Collector builds a landmark catalog (no input)
+puts "Step 1: Collector builds landmark catalog..."
+collector_result = collector.perform_task
+collector.send_message(to: "Analyst", content: collector_result)
+puts "Collector produced: #{collector_result.class}"
+puts ""
+
+# Step 2: Analyst processes the catalog
+puts "Step 2: Analyst analyzes landmark data..."
+analyst_input = analyst.inbox.last&.dig(:content)
+analyst_result = analyst.perform_task(analyst_input)
+analyst.send_message(to: "Planner", content: analyst_result)
+puts "Analyst produced: #{analyst_result.class}"
+puts ""
+
+# Step 3: Planner creates the itinerary
+puts "Step 3: Planner creates tour itinerary..."
+planner_input = planner.inbox.last&.dig(:content)
+final_itinerary = planner.perform_task(planner_input)
+puts ""
+
+# ---------------------------------------------------------------------------
+# Display results
+# ---------------------------------------------------------------------------
+
+puts "=== Final Tour Itinerary ==="
+puts final_itinerary.to_s
+puts ""
+
+bus.print_log
+puts ""
+
+# ---------------------------------------------------------------------------
+# Generation statistics
+# ---------------------------------------------------------------------------
+
+puts "=== Generation Statistics ==="
+total_methods = 0
+total_lines   = 0
+[collector, analyst, planner].each do |robot|
+  methods = robot.generation_log.size
+  lines   = robot.generation_log.sum { |e| e[:code].lines.size }
+  total_methods += methods
+  total_lines   += lines
+  puts "#{robot.name}: #{methods} method(s), #{lines} lines of generated code"
+end
+puts "Total: #{total_methods} methods, #{total_lines} lines of generated code"
+
+# ---------------------------------------------------------------------------
+# Repair statistics (if any)
+# ---------------------------------------------------------------------------
+
+all_repairs = [collector, analyst, planner].flat_map(&:repair_log)
+unless all_repairs.empty?
+  puts ""
+  puts "=== Repair Statistics ==="
+  all_repairs.each do |entry|
+    status = entry[:success] ? "SUCCESS" : "FAILED"
+    puts "  [#{status}] #{entry[:method_name]} — #{entry[:error]}"
+  end
+  puts "Total repair attempts: #{all_repairs.size}, " \
+       "successful: #{all_repairs.count { |e| e[:success] }}, " \
+       "failed: #{all_repairs.count { |e| !e[:success] }}"
+end
+
+# ---------------------------------------------------------------------------
+# Save generated robots as subclasses
+# ---------------------------------------------------------------------------
+
+puts ""
+puts "=== Saving Generated Robots ==="
+[collector, analyst, planner].each do |robot|
+  path = robot._save!(as: robot.name)
+  puts "#{robot.name}: saved to #{path}"
+end

data/examples/12_autonomous_robots/planner.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative "robot"
+
+class Planner < Robot
+  # def select_top_landmarks(ranked_landmarks, max_minutes=360)
+  #   # Select landmarks that fit within the maximum time limit
+  #   # Input: ranked_landmarks - Array of Hashes with :name, :type, :duration, :rating
+  #   #        max_minutes - Integer representing maximum time in minutes
+  #   # Output: Array of Hashes representing selected landmarks
+  #   
+  #   selected = []
+  #   total_time = 0
+  #   
+  #   ranked_landmarks.each do |landmark|
+  #     if total_time + landmark[:duration] <= max_minutes
+  #       selected << landmark
+  #       total_time += landmark[:duration]
+  #     else
+  #       break
+  #     end
+  #   end
+  #   
+  #   selected
+  # end
+  def select_top_landmarks(ranked_landmarks, max_minutes=360)
+    selected = []
+    total_time = 0
+    
+    ranked_landmarks.each do |landmark|
+      if total_time + landmark[:duration] <= max_minutes
+        selected << landmark
+        total_time += landmark[:duration]
+      else
+        break
+      end
+    end
+    
+    selected
+  end
+
+  # def format_itinerary_section(landmarks)
+  #   # Format a section of the itinerary with landmark details
+  #   # Input: landmarks - Array of Hashes with :name, :type, :duration, :rating
+  #   # Output: String representing formatted itinerary section
+  #   
+  #   return "No landmarks selected" if landmarks.empty?
+  #   
+  #   lines = ["Landmarks to Visit:"]
+  #   
+  #   landmarks.each_with_index do |landmark, index|
+  #     lines << "#{index + 1}. #{landmark[:name]} (#{landmark[:type]}) -- #{landmark[:duration]} minutes -- Rating: #{landmark[:rating]}"
+  #   end
+  #   
+  #   lines.join("\n")
+  # end
+  def format_itinerary_section(landmarks)
+    return "No landmarks selected" if landmarks.empty?
+    
+    lines = ["Landmarks to Visit:"]
+    
+    landmarks.each_with_index do |landmark, index|
+      lines << "#{index + 1}. #{landmark[:name]} (#{landmark[:type]}) -- #{landmark[:duration]} minutes -- Rating: #{landmark[:rating]}"
+    end
+    
+    lines.join("\n")
+  end
+
+  # def generate_itinerary_string(statistics, ranked_landmarks, by_type)
+  #   # Generate the complete formatted itinerary string
+  #   # Input: statistics - Hash with statistical information
+  #   #        ranked_landmarks - Array of Hashes with :name, :type, :duration, :rating
+  #   #        by_type - Hash grouping landmarks by type
+  #   # Output: String representing the complete formatted itinerary
+  #   
+  #   selected_landmarks = select_top_landmarks(ranked_landmarks)
+  #   itinerary_section = format_itinerary_section(selected_landmarks)
+  #   
+  #   "#{itinerary_section}"
+  # end
+  def generate_itinerary_string(statistics, ranked_landmarks, by_type)
+    selected_landmarks = select_top_landmarks(ranked_landmarks)
+    itinerary_section = format_itinerary_section(selected_landmarks)
+    itinerary_section
+  end
+
+  # Fix the Ruby singleton method 'execute_task' on this Robot instance.
+  # 
+  # Robot's overall goal: Create a formatted one-day tour itinerary. The input is a Hash with keys :statistics, :ranked, and :by_type. Use :ranked (an Array of Hashes with :name, :type, :duration, :rating) to select top-rated landmarks that fit within 360 total minutes of visit time. Return a String with a formatted itinerary listing each stop with its name, type, duration, and rating
+  # Generated capabilities on this object: [:select_top_landmarks, :format_itinerary_section, :generate_itinerary_string, :execute_task]
+  # 
+  # Current source code of 'execute_task':
+  # def execute_task(input)
+  #   ranked = input[:ranked]
+  #   filtered_landmarks = select_top_landmarks(ranked)
+  #   formatted_sections = filtered_landmarks.map { |landmark| format_itinerary_section(landmark) }
+  #   generate_itinerary_string(formatted_sections)
+  # end
+  # 
+  # Runtime error:
+  #   NoMethodError: undefined method '[]' for nil
+  # 
+  # Backtrace (top 5):
+  #   (eval at /Users/dewayne/sandbox/git_repos/madbomber/self_agency/lib/self_agency.rb:265):2:in 'execute_task'
+  #     /Users/dewayne/sandbox/git_repos/madbomber/self_agency/examples/12_autonomous_robots/robot.rb:72:in 'Robot#perform_task'
+  #     ./main.rb:110:in '<main>'
+  # 
+  # This method takes no external input.
+  # 
+  # Produce a corrected version of this method that avoids the error.
+  # Keep the same method name and signature. Only define this one method.
+  # Fix the bug while preserving the method's intent.
+  def execute_task(input)
+    return "" if input.nil?
+    
+    ranked = input[:ranked]
+    return "" if ranked.nil?
+    
+    filtered_landmarks = select_top_landmarks(ranked)
+    return "" if filtered_landmarks.nil? || filtered_landmarks.empty?
+    
+    formatted_sections = filtered_landmarks.map { |landmark| format_itinerary_section(landmark) }
+    generate_itinerary_string(formatted_sections)
+  end
+end

data/examples/12_autonomous_robots/robot.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+# robot.rb — Autonomous Robot with three-layer LLM self-generation
+#
+# Layer 1 (Decompose): Direct RubyLLM.chat().ask() breaks a high-level goal
+#   into a JSON array of helper method specs. The LLM decides method names,
+#   parameter signatures, and algorithms — the user only states "what", not "how".
+# Layer 2 (Generate Helpers): Loops through specs, calls _() for each.
+#   SelfAgency handles shape -> generate -> validate -> sandbox eval.
+# Layer 3 (Generate Orchestrator): A final _() call generates an execute_task
+#   method that calls the helpers in whatever order the LLM decides.
+
+require "json"
+require_relative "../lib/message_bus"
+require_relative "../lib/setup"
+
+class Robot
+  include SelfAgency
+
+  MAX_REPAIR_ATTEMPTS = 3
+
+  attr_reader :name, :goal, :bus, :inbox, :capabilities, :generation_log, :repair_log
+
+  def initialize(name:, goal:, bus:, receives_input: false)
+    @name           = name
+    @goal           = goal
+    @bus            = bus
+    @receives_input = receives_input
+    @inbox          = []
+    @capabilities   = []
+    @generation_log = []
+    @repair_log     = []
+
+    bus.register(self)
+
+    # Layer 1 — Decompose goal into helper method specs
+    puts "#{@name}: Decomposing goal..."
+    specs = decompose_task(goal)
+    puts "#{@name}: LLM decomposed goal into #{specs.size} helper(s)"
+
+    # Layer 2 — Generate each helper method via _()
+    specs.each do |spec|
+      description = spec["description"]
+      puts "#{@name}: Generating helper — #{description[0, 80]}..."
+
+      begin
+        defined_methods = _(description, scope: :singleton)
+        @capabilities.concat(defined_methods)
+        puts "#{@name}: Generated #{defined_methods.inspect}"
+      rescue SelfAgency::Error => e
+        puts "#{@name}: Failed to generate helper: #{e.message}"
+      end
+    end
+
+    # Layer 3 — Generate orchestrator that calls the helpers
+    puts "#{@name}: Generating orchestrator for #{@capabilities.size} helper(s)..."
+    generate_orchestrator
+
+    puts "#{@name}: Ready with capabilities: #{@capabilities.inspect}"
+  end
+
+  def perform_task(input = nil)
+    attempts = 0
+
+    begin
+      arity = method(:execute_task).arity
+      puts "#{@name}: Running execute_task (input: #{input.class})"
+
+      if arity == 0
+        execute_task
+      else
+        execute_task(input)
+      end
+    rescue => error
+      attempts += 1
+      puts "#{@name}: Error (attempt #{attempts}/#{MAX_REPAIR_ATTEMPTS}): #{error.class}: #{error.message}"
+
+      if attempts < MAX_REPAIR_ATTEMPTS
+        repair_method(error, input)
+        retry
+      else
+        puts "#{@name}: MALFUNCTION — failed after #{MAX_REPAIR_ATTEMPTS} repair attempts: #{error.message}"
+        nil
+      end
+    end
+  end
+
+  def receive_message(from:, content:)
+    @inbox << { from: from, content: content }
+    puts "#{@name}: Received message from #{from}"
+  end
+
+  def send_message(to:, content:)
+    @bus.deliver(from: @name, to: to, content: content)
+  end
+
+  def broadcast(content:)
+    @bus.broadcast(from: @name, content: content)
+  end
+
+  def on_method_generated(method_name, scope, code)
+    @generation_log << { method_name: method_name, scope: scope, code: code }
+  end
+
+  private
+
+  # Self-repair: identify the failing method from the backtrace, regenerate it via LLM.
+  # Includes goal, capabilities, input shape, and sibling source for full context.
+  def repair_method(error, input = nil)
+    failing_method = identify_failing_method(error)
+    current_source = find_generated_source(failing_method)
+    puts "#{@name}: Repairing #{failing_method.inspect}"
+
+    # Build a snapshot of all generated method sources for context
+    sibling_sources = @generation_log
+      .select { |e| e[:method_name] != failing_method }
+      .map { |e| "  def #{e[:method_name]}(...) — see generation log" }
+      .join("\n")
+
+    # Describe the input data shape so the LLM understands what it's working with
+    input_shape = describe_data_shape(input)
+
+    description = <<~DESC
+      Fix the Ruby singleton method '#{failing_method}' on this Robot instance.
+
+      Robot's overall goal: #{@goal}
+      Generated capabilities on this object: #{@capabilities.inspect}
+
+      Current source code of '#{failing_method}':
+      #{current_source}
+
+      Runtime error:
+        #{error.class}: #{error.message}
+
+      Backtrace (top 5):
+        #{error.backtrace&.first(5)&.join("\n    ")}
+
+      #{input_shape}
+
+      Produce a corrected version of this method that avoids the error.
+      Keep the same method name and signature. Only define this one method.
+      Fix the bug while preserving the method's intent.
+    DESC
+
+    defined_methods = _(description, scope: :singleton)
+    @repair_log << { method_name: failing_method, error: "#{error.class}: #{error.message}", success: true }
+    puts "#{@name}: Repaired #{failing_method} -> #{defined_methods.inspect}"
+  rescue SelfAgency::Error => e
+    @repair_log << { method_name: failing_method, error: "#{error.class}: #{error.message}", success: false }
+    puts "#{@name}: Repair generation failed: #{e.message}"
+  end
+
+  # Scan the backtrace for a method name that matches one of our generated capabilities.
+  # Handles both Ruby <3.4 (`method') and Ruby >=3.4 ('Class#method') backtrace formats.
+  def identify_failing_method(error)
+    return :execute_task unless error.backtrace
+
+    error.backtrace.each do |line|
+      match = line.match(/in ['`](?:\w+#)?(\w+)'/)
+      next unless match
+
+      method_name = match[1].to_sym
+      return method_name if @capabilities.include?(method_name) && method_name != :execute_task
+    end
+
+    :execute_task
+  end
+
+  # Look up the most recent generated source for a method from the generation log.
+  def find_generated_source(method_name)
+    entry = @generation_log.reverse.find { |e| e[:method_name] == method_name }
+    entry ? entry[:code] : "(source not found)"
+  end
+
+  # Build a human-readable description of the input data shape for the repair prompt.
+  # Shows class, keys, and a sample element so the LLM understands the actual structure.
+  def describe_data_shape(input)
+    return "This method takes no external input." if input.nil?
+
+    lines = ["The execute_task method received input of type #{input.class}."]
+
+    case input
+    when Hash
+      lines << "Top-level keys: #{input.keys.inspect}"
+      input.each do |key, value|
+        case value
+        when Array
+          lines << "  input[#{key.inspect}] is an Array with #{value.size} element(s)."
+          if value.first.is_a?(Hash)
+            lines << "  Sample element keys: #{value.first.keys.inspect}"
+            lines << "  Sample element: #{value.first.inspect[0, 200]}"
+          end
+        else
+          lines << "  input[#{key.inspect}] is a #{value.class}: #{value.inspect[0, 100]}"
+        end
+      end
+    when Array
+      lines << "Array with #{input.size} element(s)."
+      if input.first.is_a?(Hash)
+        lines << "Sample element keys: #{input.first.keys.inspect}"
+        lines << "Sample element: #{input.first.inspect[0, 200]}"
+      end
+    else
+      lines << "Value preview: #{input.inspect[0, 200]}"
+    end
+
+    lines.join("\n")
+  end
+
+  # Layer 1 — Ask the LLM to decompose a high-level goal into helper method specs.
+  # Returns an Array of Hashes with "description" keys.
+  def decompose_task(goal)
+    cfg  = SelfAgency.configuration
+    chat = RubyLLM.chat(model: cfg.model, provider: cfg.provider)
+
+    prompt = <<~PROMPT
+      You are an autonomous task decomposition engine. Given a high-level goal,
+      decide what Ruby helper methods are needed to accomplish it. YOU choose
+      the method names, parameters, algorithms, and data structures.
+
+      Return a JSON array of method specifications. Each element must have:
+        - "description": a precise Ruby method specification including the method
+          name you chose (snake_case), parameter names and types, return type,
+          and a detailed algorithm. This description will be given to a Ruby code
+          generator, so be precise and complete.
+
+      Rules:
+        - Choose clear, descriptive method names
+        - Design clean data structures (prefer Hashes with Symbol keys and Arrays)
+        - Each method should do one thing well
+        - Methods should be composable — later methods can use output of earlier ones
+        - Do NOT include an orchestrator method — only helper methods
+        - Keep to 2-4 helper methods maximum
+
+      Respond with ONLY the JSON array. No markdown fences, no explanation.
+
+      Goal: #{goal}
+    PROMPT
+
+    response = chat.ask(prompt)
+    raw      = response.content.to_s.strip
+
+    raw = raw.gsub(/<think>.*?<\/think>/m, "")
+    raw = raw.sub(/\A```\w*\n?/, "").sub(/\n?```\s*\z/, "")
+    raw.strip!
+
+    JSON.parse(raw)
+  rescue JSON::ParserError => e
+    puts "#{@name}: Failed to parse decomposition: #{e.message}"
+    []
+  end
+
+  # Layer 3 — Generate an orchestrator method that calls the helpers.
+  # The LLM decides how to wire the helpers together to achieve the goal.
+  def generate_orchestrator
+    helper_list = @capabilities.map(&:to_s).join(", ")
+    input_clause = if @receives_input
+                     "It takes one parameter (input) which is the data passed in from a previous stage."
+                   else
+                     "It takes no parameters."
+                   end
+
+    description = <<~DESC
+      An instance method named 'execute_task' that orchestrates the following
+      goal: #{@goal}
+
+      #{input_clause}
+
+      Available helper methods on this object: #{helper_list}
+
+      Call the helper methods in whatever order makes sense to accomplish the goal.
+      Return the final result. Do NOT define the helper methods — they already exist.
+      Only define the execute_task method itself.
+    DESC
+
+    begin
+      defined_methods = _(description, scope: :singleton)
+      @capabilities.concat(defined_methods)
+      puts "#{@name}: Generated orchestrator #{defined_methods.inspect}"
+    rescue SelfAgency::Error => e
+      puts "#{@name}: Failed to generate orchestrator: #{e.message}"
+    end
+  end
+end

data/examples/generated/from_range_class.rb

@@ -0,0 +1,3 @@
+def self.from_range(low, high)
+  new((low..high).to_a)
+end

data/examples/generated/mean_instance.rb

@@ -0,0 +1,4 @@
+def mean
+  return Float::NAN if @data.empty?
+  @data.sum.to_f / @data.size
+end

data/examples/generated/median_instance.rb

@@ -0,0 +1,15 @@
+def median
+  return 0.0 if @data.nil? || @data.empty?
+  
+  sorted_data = @data.sort
+  length = sorted_data.length
+  
+  if length.odd?
+    middle_index = length / 2
+    sorted_data[middle_index].to_f
+  else
+    right_middle_index = length / 2
+    left_middle_index = right_middle_index - 1
+    (sorted_data[left_middle_index] + sorted_data[right_middle_index]).to_f / 2.0
+  end
+end

data/examples/generated/report_singleton.rb

@@ -0,0 +1,3 @@
+def report
+  "Data count: #{@data.length}\nMean: #{self.mean}\nMedian: #{self.median}\nStandard deviation: #{self.standard_deviation}"
+end

data/examples/generated/standard_deviation_instance.rb

@@ -0,0 +1,8 @@
+def standard_deviation
+  return 0.0 if @data.nil? || @data.empty?
+  
+  mean = @data.sum.to_f / @data.length
+  squared_differences = @data.map { |x| (x - mean) ** 2 }
+  variance = squared_differences.sum.to_f / squared_differences.length
+  Math.sqrt(variance)
+end

data/examples/lib/message_bus.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# message_bus.rb — Simple pub/sub message bus for robot collaboration
+#
+# Provides point-to-point delivery and broadcast messaging between
+# registered robots. No SelfAgency dependency — plain infrastructure.
+
+
+class MessageBus
+  attr_reader :log
+
+  def initialize
+    @robots = {}
+    @log    = []
+  end
+
+  def register(robot)
+    @robots[robot.name] = robot
+    puts "MessageBus: registered robot '#{robot.name}'"
+  end
+
+  def deliver(from:, to:, content:)
+    recipient = @robots[to]
+    unless recipient
+      puts "MessageBus: unknown recipient '#{to}'"
+      return
+    end
+
+    @log << { from: from, to: to, content: content }
+    recipient.receive_message(from: from, content: content)
+    puts "MessageBus: #{from} -> #{to} (#{content_preview(content)})"
+  end
+
+  def broadcast(from:, content:)
+    @robots.each do |name, robot|
+      next if name == from
+
+      @log << { from: from, to: name, content: content }
+      robot.receive_message(from: from, content: content)
+    end
+    puts "MessageBus: #{from} -> broadcast (#{content_preview(content)})"
+  end
+
+  def print_log
+    puts "=== Message Bus Log (#{@log.size} messages) ==="
+    @log.each_with_index do |entry, i|
+      puts "  #{i + 1}. #{entry[:from]} -> #{entry[:to]}: #{content_preview(entry[:content])}"
+    end
+  end
+
+  private
+
+  def content_preview(content)
+    text = content.to_s
+    text.length > 80 ? "#{text[0, 77]}..." : text
+  end
+end

data/examples/lib/setup.rb

@@ -0,0 +1,8 @@
+require_relative "../../lib/self_agency"
+
+SelfAgency.configure do |config|
+  config.provider        = :ollama
+  config.model           = "qwen3-coder:30b"
+  config.api_base        = "http://localhost:11434/v1"
+  config.request_timeout = 120
+end