agent_c 2.71828

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,188 @@
+# 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_step(name, **params, &block)
+        step(name) do
+          resolved_params = (
+            if block
+              instance_exec(&block)
+            elsif params.empty?
+              i18n_attributes = (
+                if record.respond_to?(:i18n_attributes)
+                  record.i18n_attributes
+                else
+                  record.attributes
+                end
+              )
+
+              {
+                tool_args: {
+                  workspace_dir: workspace.dir,
+                  env: workspace.env,
+                },
+                cached_prompt: I18n.t("#{name}.cached_prompts"),
+                prompt: I18n.t("#{name}.prompt", **i18n_attributes.symbolize_keys),
+                tools: I18n.t("#{name}.tools"),
+                schema: -> {
+                  next unless I18n.exists?("#{name}.response_schema")
+
+                  I18n.t("#{name}.response_schema").each do |name, spec|
+                    extra = spec.except(:required, :description, :type)
+
+                    if extra.key?(:of)
+                      extra[:of] = extra[:of]&.to_sym
+                    end
+
+                    send(
+                      spec.fetch(:type, "string"),
+                      name,
+                      required: spec.fetch(:required, true),
+                      description: spec.fetch(:description),
+                      **extra
+                    )
+                  end
+                }
+              }
+            else
+              i18n_attributes = (
+                if record.respond_to?(:i18n_attributes)
+                  record.i18n_attributes
+                else
+                  record.attributes
+                end
+              )
+
+              {
+                tool_args: {
+                  workspace_dir: workspace.dir,
+                  env: workspace.env,
+                }
+              }.tap { |hash|
+                if params.key?(:prompt_key)
+                  hash[:prompt] = I18n.t(params[:prompt_key],  **i18n_attributes.symbolize_keys)
+                end
+
+                if params.key?(:cached_prompt_keys)
+                  hash[:cached_prompt] = params[:cached_prompt_keys].map { I18n.t(_1) }
+                end
+              }.merge(params.except(:cached_prompt_keys, :prompt_key))
+            end
+          )
+
+          result = session.prompt(
+            on_chat_created: -> (id) { task.chat_ids << id},
+            **resolved_params
+          )
+
+          if result.success?
+            task.record.update!(result.data)
+          else
+            task.fail!(result.error_message)
+          end
+        end
+      end
+    end
+
+    def call
+      raise "Task.workspace is nil" unless task.workspace
+
+      log("start")
+
+      self.class.steps.each do |step|
+        break if task.failed?
+
+
+        store.transaction do
+          log_prefix = "step: '#{step.name}'"
+
+          if task.completed_steps.include?(step.name.to_s)
+            log("#{log_prefix} already completed, skipping")
+            next
+          end
+
+          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)}
+          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 repo
+      @repo ||= @git.call(workspace.dir)
+    end
+
+    def log(msg)
+      logger.info("task: #{task.id}: #{msg}")
+    end
+
+    def logger
+      session.logger
+    end
+  end
+end

data/lib/agent_c/processor.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module AgentC
+  class Processor
+    Handler = Data.define(:task, :handler) do
+      def call
+        handler.call(task)
+        if task.pending?
+          raise "Task Pending error"
+        end
+      end
+    end
+
+    attr_reader :context, :handlers
+    def initialize(context:, handlers:)
+      @context = context
+      @handlers = handlers.transform_keys(&:to_s)
+    end
+
+    def add_task(record, handler)
+      raise ArgumentError.new("invalid handler") unless handlers.include?(handler.to_s)
+
+      store.task.find_or_create_by!(record:, handler:)
+    end
+
+    def call(&)
+      raise "must provide at least one workspace" if workspace_count == 0
+
+      if workspace_count == 1
+        call_synchronous(context.workspaces.first, &)
+      else
+        call_asynchronous(&)
+      end
+    end
+
+    def abort!
+      @abort = true
+    end
+
+    def abort?
+      @abort
+    end
+
+    private
+
+    def call_asynchronous(&)
+      error = nil
+
+      Async { |task|
+        semaphore = Async::Semaphore.new(workspace_count)
+
+        context.workspaces.map  { |workspace|
+          semaphore.async do
+            call_synchronous(workspace, &)
+          rescue => e
+            abort!
+            error = e
+          end
+        }
+
+      }.wait
+
+      raise error if error
+    end
+
+    def call_synchronous(workspace)
+      while(handler = next_handler(workspace))
+        handler.call
+        yield if block_given? # allow the invoker to do work inbetween handler calls
+      end
+    end
+
+    def next_handler(workspace)
+      return nil if abort?
+
+      task = (
+        store
+          .task
+          .where("workspace_id = ? OR workspace_id IS NULL", workspace.id)
+          .order("created_at ASC")
+          .find_by(status: :pending)
+      )
+
+      if task
+        task.update!(workspace:) unless task.workspace
+        Handler.new(task:, handler: handlers.fetch(task.handler))
+      end
+    end
+
+    def workspace_count
+      @workspace_count ||= context.workspaces.count
+    end
+
+    def store
+      context.store
+    end
+  end
+end