agent_c 2.9

data/lib/agent_c/costs/report.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module AgentC
+  module Costs
+    class Report
+
+# Anthropic models	Price per 1,000 input tokens	Price per 1,000 output tokens	Price per 1,000 input tokens (batch)	Price per 1,000 output tokens (batch)	Price per 1,000 input tokens (5m cache write)	Price per 1,000 input tokens (1h cache write)	Price per 1,000 input tokens (cache read)
+# Claude Sonnet 4.5	$0.003	$0.015	$0.0015	$0.0075	$0.00375	$0.006	$0.0003
+# Claude Sonnet 4.5 - Long Context	$0.006	$0.0225	$0.003	$0.01125	$0.0075	$0.012	$0.0006
+
+      PRICING = {
+        normal: {
+          input: 3.0,              # $0.003 per 1k tokens
+          output: 15.0,            # $0.015 per 1k tokens
+          cached_input: 0.3,       # $0.0003 per 1k tokens (cache read)
+          cache_creation: 3.75     # $0.00375 per 1k tokens (5m cache write)
+        },
+        long: {
+          input: 6.0,              # $0.006 per 1k tokens
+          output: 22.5,            # $0.0225 per 1k tokens
+          cached_input: 0.6,       # $0.0006 per 1k tokens (cache read)
+          cache_creation: 7.5      # $0.0075 per 1k tokens (5m cache write)
+        }
+      }.freeze
+
+      LONG_CONTEXT_THRESHOLD = 200_000 # tokens
+
+      def self.call(...)
+        new(...).call
+      end
+
+      def initialize(agent_store:, project: nil, run_id: nil, out: $stdout)
+        @agent_store = agent_store
+        @project = project
+        @run_id = run_id
+        @out = out
+        @calculator = Calculator.new
+        @printer = Printer.new(out: @out)
+      end
+
+      def call
+        # Gather all computations based on hierarchy
+        computations = []
+
+        # Always compute totals for all projects
+        all_messages = fetch_all_messages
+        if all_messages.any?
+          computations << {
+            label: "All Projects",
+            stats: @calculator.calculate(all_messages),
+            messages: all_messages
+          }
+        end
+
+        # If project is specified, add project-level computation
+        if @project
+          project_messages = fetch_project_messages
+          if project_messages.any?
+            computations << {
+              label: "Project: #{@project}",
+              stats: @calculator.calculate(project_messages),
+              messages: project_messages
+            }
+          end
+
+          # If run_id is also specified, add run-level computation
+          if @run_id
+            run_messages = fetch_run_messages
+            if run_messages.any?
+              computations << {
+                label: "Project: #{@project}, Run ID: #{@run_id}",
+                stats: @calculator.calculate(run_messages),
+                messages: run_messages
+              }
+            end
+          end
+        end
+
+        if computations.empty?
+          @out.puts "No messages found" if @out
+          return []
+        end
+
+        # Print to output if provided
+        if @out
+          @printer.print_hierarchical_report(computations)
+        end
+
+        # Return structured data
+        computations
+      end
+
+      private
+
+      def fetch_all_messages
+        @agent_store.message
+          .joins(:chat)
+          .includes(:model, :chat)
+      end
+
+      def fetch_project_messages
+        @agent_store.message
+          .joins(:chat)
+          .where(chats: { project: @project })
+          .includes(:model, :chat)
+      end
+
+      def fetch_run_messages
+        @agent_store.message
+          .joins(:chat)
+          .where(chats: { project: @project, run_id: @run_id })
+          .includes(:model, :chat)
+      end
+
+      # Calculator class for computing costs
+      class Calculator
+        def calculate(messages)
+          stats = {
+            input_tokens: 0,
+            output_tokens: 0,
+            cached_tokens: 0,
+            cache_creation_tokens: 0,
+            input_cost: 0.0,
+            output_cost: 0.0,
+            cached_cost: 0.0,
+            cache_creation_cost: 0.0,
+            total_cost: 0.0,
+            message_count: messages.count
+          }
+
+          messages.each do |message|
+            stats[:input_tokens] += message.input_tokens || 0
+            stats[:output_tokens] += message.output_tokens || 0
+            stats[:cached_tokens] += message.cached_tokens || 0
+            stats[:cache_creation_tokens] += message.cache_creation_tokens || 0
+
+            # Determine which pricing tier to use based on total token count
+            total_message_tokens = (message.input_tokens || 0) +
+                                   (message.cached_tokens || 0) +
+                                   (message.cache_creation_tokens || 0)
+            pricing = total_message_tokens > LONG_CONTEXT_THRESHOLD ? PRICING[:long] : PRICING[:normal]
+
+            # Calculate cost using appropriate pricing tier
+            # Input tokens cost
+            if message.input_tokens && message.input_tokens > 0
+              cost = (message.input_tokens / 1_000_000.0) * pricing[:input]
+              stats[:input_cost] += cost
+              stats[:total_cost] += cost
+            end
+
+            # Output tokens cost
+            if message.output_tokens && message.output_tokens > 0
+              cost = (message.output_tokens / 1_000_000.0) * pricing[:output]
+              stats[:output_cost] += cost
+              stats[:total_cost] += cost
+            end
+
+            # Cached tokens cost (cache read)
+            if message.cached_tokens && message.cached_tokens > 0
+              cost = (message.cached_tokens / 1_000_000.0) * pricing[:cached_input]
+              stats[:cached_cost] += cost
+              stats[:total_cost] += cost
+            end
+
+            # Cache creation tokens cost
+            if message.cache_creation_tokens && message.cache_creation_tokens > 0
+              cost = (message.cache_creation_tokens / 1_000_000.0) * pricing[:cache_creation]
+              stats[:cache_creation_cost] += cost
+              stats[:total_cost] += cost
+            end
+          end
+
+          stats
+        end
+      end
+
+      # Printer class for formatting output
+      class Printer
+        def initialize(out: $stdout)
+          @out = out
+        end
+
+        def print_hierarchical_report(computations)
+          computations.each_with_index do |computation, index|
+            print_section(computation[:label], computation[:stats], computation[:messages])
+            @out.puts "" if index < computations.length - 1
+          end
+        end
+
+        private
+
+        def print_section(label, stats, messages)
+          total_tokens = stats[:input_tokens] + stats[:output_tokens] + stats[:cached_tokens] + stats[:cache_creation_tokens]
+
+          @out.puts <<~REPORT
+            ============================================================
+            Cost Report: #{label}
+            ============================================================
+            Messages: #{stats[:message_count]}
+            Chats: #{messages.map(&:chat).uniq.count}
+            ------------------------------------------------------------
+            Token Usage:
+              Input tokens:           #{format_number(stats[:input_tokens]).rjust(15)}  $#{format('%.4f', stats[:input_cost]).rjust(8)}
+              Output tokens:          #{format_number(stats[:output_tokens]).rjust(15)}  $#{format('%.4f', stats[:output_cost]).rjust(8)}
+              Cached tokens:          #{format_number(stats[:cached_tokens]).rjust(15)}  $#{format('%.4f', stats[:cached_cost]).rjust(8)}
+              Cache creation tokens:  #{format_number(stats[:cache_creation_tokens]).rjust(15)}  $#{format('%.4f', stats[:cache_creation_cost]).rjust(8)}
+            ------------------------------------------------------------
+              Total:                  #{format_number(total_tokens).rjust(15)}  $#{format('%.4f', stats[:total_cost]).rjust(8)}
+            ============================================================
+          REPORT
+        end
+
+        def format_number(num)
+          num.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+        end
+      end
+    end
+  end
+end

data/lib/agent_c/db/store.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+require "ruby_llm/active_record/acts_as"
+
+module AgentC
+  module Db
+    class Store < VersionedStore::Base
+      record(:model) do
+        schema :models do |t|
+          t.string :model_id, null: false
+          t.string :name, null: false
+          t.string :provider, null: false
+          t.string :family
+          t.datetime :model_created_at
+          t.integer :context_window
+          t.integer :max_output_tokens
+          t.date :knowledge_cutoff
+          t.json :modalities, default: {}
+          t.json :capabilities, default: []
+          t.json :pricing, default: {}
+          t.json :metadata, default: {}
+          t.timestamps
+
+          t.index [:provider, :model_id], unique: true
+          t.index :provider
+          t.index :family
+        end
+
+        include RubyLLM::ActiveRecord::ActsAs
+        acts_as_model chats: :chats, chat_class: class_name(:chat)
+      end
+
+      record(:chat) do
+        schema :chats do |t|
+          t.references :model, foreign_key: true
+          t.string :project
+          t.string :run_id
+          t.timestamps
+        end
+
+        include RubyLLM::ActiveRecord::ActsAs
+
+        acts_as_chat(
+          messages: :messages,
+          message_class: class_name(:message),
+          messages_foreign_key: :chat_id,
+          model: :model,
+          model_class: class_name(:model),
+          model_foreign_key: :model_id
+        )
+
+        belongs_to(
+          :model,
+          class_name: class_name(:model),
+          required: false
+        )
+
+        validates :model, presence: true
+
+        def messages_hash
+          messages
+            .map {
+              hash = _1.to_llm.to_h
+
+              if hash.key?(:tool_calls)
+                hash[:tool_calls] = hash.fetch(:tool_calls).values.map(&:to_h)
+              end
+
+              if hash.key?(:content) && !hash[:content].is_a?(String)
+                hash[:content] = hash[:content].to_h
+              end
+
+              hash
+            }
+        end
+      end
+
+      record(:message) do
+        schema :messages do |t|
+          t.references :chat, null: false, foreign_key: true
+          t.references :model, foreign_key: true
+          t.references :tool_call, foreign_key: true
+          t.string :role, null: false
+          t.text :content
+          t.json :content_raw
+          t.integer :input_tokens
+          t.integer :output_tokens
+          t.integer :cached_tokens
+          t.integer :cache_creation_tokens
+          t.timestamps
+
+          t.index :role
+        end
+
+        include RubyLLM::ActiveRecord::ActsAs
+
+        acts_as_message(
+          chat: :chat,
+          chat_class: class_name(:chat),
+          chat_foreign_key: :chat_id,
+          tool_calls: :tool_calls,
+          tool_call_class: class_name(:tool_call),
+          tool_calls_foreign_key: :message_id,
+          model: :model,
+          model_class: class_name(:model),
+          model_foreign_key: :model_id
+        )
+
+        belongs_to(
+          :chat,
+          class_name: class_name(:chat),
+          required: false
+        )
+
+        belongs_to(
+          :model,
+          class_name: class_name(:model),
+          required: false
+        )
+
+        belongs_to(
+          :tool_call,
+          class_name: class_name(:tool_call),
+          required: false
+        )
+
+        validates :role, presence: true
+        validates :chat, presence: true
+      end
+
+      record(:tool_call) do
+        schema :tool_calls do |t|
+          t.references :message, null: false, foreign_key: true
+          t.string :tool_call_id, null: false
+          t.string :name, null: false
+          t.json :arguments, default: {}
+          t.timestamps
+
+          t.index :tool_call_id, unique: true
+          t.index :name
+        end
+
+        include RubyLLM::ActiveRecord::ActsAs
+
+        acts_as_tool_call(
+          message: :message,
+          message_class: class_name(:message),
+          message_foreign_key: :message_id,
+          result: :result,
+          result_class: class_name(:message)
+        )
+
+        belongs_to(
+          :message,
+          class_name: class_name(:message),
+          required: false
+        )
+      end
+    end
+  end
+end

data/lib/agent_c/errors.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module AgentC
+  module Errors
+    class Base < StandardError
+    end
+
+    class AbortCostExceeded < Base
+      attr_reader :cost_type, :current_cost, :threshold
+
+      def initialize(cost_type:, current_cost:, threshold:)
+        @cost_type = cost_type
+        @current_cost = current_cost
+        @threshold = threshold
+        super("Abort: #{cost_type} cost $#{current_cost.round(2)} exceeds threshold $#{threshold.round(2)}")
+      end
+    end
+  end
+end

data/lib/agent_c/pipeline.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module AgentC
+  class Pipeline
+    def self.call(...)
+      new(...).tap(&:call)
+    end
+
+    attr_reader :session, :task
+    def initialize(
+      session:,
+      task:,
+      git: ->(dir) { Utils::Git.new(dir) }
+    )
+      @session = session
+      @task = task
+      @git = git
+    end
+
+    Step = Data.define(:name, :block)
+
+    class << self
+      def on_failures
+        @on_failures ||= []
+      end
+
+      def steps
+        @steps ||= []
+      end
+
+      def on_failure(&block)
+        self.on_failures << block
+      end
+
+      def step(name, &block)
+        self.steps << Step.new(name:, block:)
+      end
+
+      def agent_review_loop(name, **params)
+        step(name) do
+          agent = Pipelines::Agent.new(self)
+          agent.agent_review_loop(name, **params)
+        end
+      end
+
+      def agent_step(name, **params, &block)
+        raise ArgumentError.new("Can't pass block and params") if params.any? && block
+
+        step(name) do
+          agent = Pipelines::Agent.new(self)
+          agent.agent_step(name, **params, &block)
+        end
+      end
+    end
+
+    def call
+      raise "Task.workspace is nil" unless task.workspace
+
+      log("start")
+
+      while(task.pending?)
+        break if task.failed?
+
+        step = self.class.steps.find { !task.completed_steps.include?(_1.name.to_s) }
+        break if step.nil?
+
+        @rewind_to = nil
+
+        store.transaction do
+          log_prefix = "step: '#{step.name}'"
+
+          log("#{log_prefix} start")
+
+          instance_exec(&step.block)
+
+          if task.failed?
+            log("#{log_prefix} failed, executing on_failures")
+            self.class.on_failures.each { instance_exec(&_1)}
+          elsif @rewind_to
+            matching_steps = task.completed_steps.select { _1 == @rewind_to }
+
+            if matching_steps.count == 0
+              raise ArgumentError, <<~TXT
+                Cannot rewind to a step that's not been completed yet:
+
+                rewind_to!(#{@rewind_to.inspect})
+                completed_steps: #{task.completed_steps.inspect}
+              TXT
+            elsif matching_steps.count > 1
+              raise ArgumentError, <<~TXT
+                Cannot rewind to a step with a non-distinct name. The step
+                name appears multiple times:
+
+                rewind_to!(#{@rewind_to.inspect})
+                completed_steps: #{task.completed_steps.inspect}
+              TXT
+            end
+
+            log("#{log_prefix} rewind_to! #{@rewind_to.inspect}")
+            task
+              .completed_steps
+              .index(@rewind_to)
+              .then { task.update!(completed_steps: task.completed_steps[0..._1]) }
+          else
+            log("#{log_prefix} done")
+            task.completed_steps << step.name.to_s
+          end
+        end
+      end
+
+      store.transaction do
+        log("done")
+        task.done! unless task.failed?
+      end
+    rescue => e
+      store.transaction do
+        log("Exception raised, running on_failures")
+        task.fail!(["#{e.class.name}:#{e.message}", e.backtrace].join("\n"))
+        self.class.on_failures.each { instance_exec(&_1) }
+      end
+    end
+
+    def workspace
+      task.workspace
+    end
+
+    def record
+      task.record
+    end
+
+    def store
+      task.store
+    end
+
+    def rewind_to!(step)
+      @rewind_to = step.to_s
+    end
+
+    def git
+      @_git ||= @git.call(workspace.dir)
+    end
+
+    def log(msg)
+      logger.info("task: #{task.id}: #{msg}")
+    end
+
+    def logger
+      session.logger
+    end
+
+  end
+end