agent_c 2.9

data/lib/agent_c/agent/chat.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+require "json-schema"
+
+module AgentC
+  module Agent
+    class Chat
+    attr_reader :id, :logger, :tools, :cached_prompts, :session
+
+    def initialize(
+      tools: Tools.all,
+      cached_prompts: [],
+      workspace_dir: nil,
+      record:, # Can be used for testing or continuing existing chats
+      session: nil
+    )
+      @session = session
+      @logger = session&.config&.logger
+      @tools = tools.map do
+        if _1.is_a?(Symbol)
+          Tools.resolve(
+            value: _1,
+            available_tools: Tools::NAMES.merge(session&.config&.extra_tools || {}),
+            args: {},
+            workspace_dir: workspace_dir || session&.config&.workspace_dir
+          )
+        else
+          _1
+        end
+      end
+      @cached_prompts = cached_prompts
+      @record_param = record
+    end
+
+    def ask(msg)
+      record.ask(msg)
+    end
+
+    def id
+      record.id
+    end
+
+    def to_h
+      record
+        .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
+
+          hash
+        }
+    end
+
+    NONE = Object.new
+
+    def refine(msg, schema:, times: 2)
+      schema = normalize_schema(schema)
+
+      requests = 0
+      last_answer = NONE
+
+      while(requests < times)
+        requests += 1
+        full_msg = (
+          if last_answer == NONE
+            msg
+          else
+            I18n.t(
+              "agent.chat.refine.system_message",
+              prior_answer: last_answer,
+              original_message: msg
+            )
+          end
+        )
+
+        last_answer = get_result(full_msg, schema:)
+      end
+
+      last_answer
+    end
+
+    def get(msg, schema: nil, confirm: 1, out_of: 1)
+      requests = 0
+      answers = []
+
+      confirmed_answer = NONE
+
+      while(requests < out_of && confirmed_answer == NONE)
+        requests += 1
+        answers << get_result(msg, schema:)
+
+        current_result = answers.group_by { _1 }.find { _2.count >= confirm }
+
+        if current_result
+          confirmed_answer = current_result.first
+        end
+      end
+
+      if confirmed_answer == NONE
+        raise "Unable to confirm an answer:\n#{JSON.pretty_generate(answers)}"
+      end
+
+      confirmed_answer
+    end
+
+    def messages(...)
+      record.messages(...)
+    end
+
+    def record
+      @record ||= begin
+        # If a record was injected (for continuing existing chat), use it
+        # Otherwise create a new chat
+
+        # Set up callbacks and tools
+        @record_param
+          .with_tools(*tools.flatten)
+          .on_new_message { log("message start") }
+          .on_end_message do |message|
+            log("message end: #{serialize_for_log(message).to_json}")
+          end
+          .on_tool_call { log("tool_call: #{serialize_for_log(_1).to_json}") }
+          .on_tool_result { log("tool_result: #{_1}") }
+      end
+    end
+
+    private
+
+    def normalize_schema(schema)
+      if schema.is_a?(Schema::AnyOneOf)
+        schema
+      elsif schema.is_a?(Array)
+        Schema::AnyOneOf.new(*schema)
+      else
+        Schema::AnyOneOf.new(schema)
+      end
+    end
+
+    def log(msg)
+      logger&.debug("chat-#{id}: #{msg}")
+    end
+
+    def serialize_for_log(message)
+      hash = message.to_h
+
+      return hash unless hash.key?(:tool_calls)
+
+      hash.merge(
+        tool_calls: hash.fetch(:tool_calls).values.map(&:to_h)
+      )
+    end
+
+    def get_result(msg, schema:)
+      tries = 0
+      success = false
+      json_schema = schema&.to_json_schema&.fetch(:schema)
+      result = nil
+
+      message = I18n.t("agent.chat.get_result.json_instructions")
+
+      if schema
+        message += I18n.t(
+          "agent.chat.get_result.schema_requirement",
+          json_schema: json_schema.to_json
+        )
+      end
+
+      message += I18n.t("agent.chat.get_result.request_wrapper", msg: msg)
+
+      while (!success && tries < 5)
+        begin
+          response = ask(message)
+          json = JSON.parse(response.content.sub(/\A```json/, "").sub(/```\Z/, ""))
+
+          if json_schema.nil? || JSON::Validator.validate(json_schema, json)
+            success = true
+            result = json
+          else
+            errors = (
+              begin
+                JSON::Validator.fully_validate(json_schema, json)
+              rescue => e
+                e.message
+              end
+            )
+
+            message = I18n.t(
+              "agent.chat.get_result.schema_validation_error",
+              errors: errors
+            )
+          end
+        rescue JSON::ParserError => e
+          message = I18n.t("agent.chat.get_result.json_parse_error")
+        end
+
+        tries += 1
+      end
+
+      raise "Failed to get valid response" if !success
+
+      result
+    end
+
+
+    end
+  end
+end

data/lib/agent_c/agent/chat_response.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module AgentC
+  module Agent
+    class ChatResponse
+    attr_reader :chat_id, :raw_response
+
+    def initialize(chat_id:, raw_response:)
+      @chat_id = chat_id
+      @raw_response = raw_response
+    end
+
+    def success?
+      !@raw_response.key?("unable_to_fulfill_request_error")
+    end
+
+    def status
+      if success?
+        "success"
+      else
+        "error"
+      end
+    end
+
+    def data
+      raise "Cannot call data on failed response. Use error_message instead." unless success?
+
+      raw_response
+    end
+
+    def error_message
+      raise "Cannot call error_message on successful response. Use data instead." if success?
+
+      raw_response.fetch("unable_to_fulfill_request_error")
+    end
+    end
+  end
+end

data/lib/agent_c/agent/chats/anthropic_bedrock.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module AgentC
+  module Agent
+    module Chats
+      module AnthropicBedrock
+      def self.create(project:, run_id:, prompts:, agent_store:, ruby_llm_context:)
+        ruby_llm_config = ruby_llm_context.config
+
+        chat = agent_store.chat
+          .create!(
+            model: agent_store.model.find_or_create_by!(
+              model_id: ruby_llm_config.default_model,
+              provider: "bedrock"
+            ) { |m|
+              m.name = "Claude Sonnet 4.5"
+              m.family = "claude"
+            },
+            project: project,
+            run_id: run_id
+          )
+
+        # Set the context on the chat record so to_llm can use it
+        chat.define_singleton_method(:context) { ruby_llm_context }
+
+        chat.tap { |chat|
+          if prompts.any?
+            # WARN -- RubyLLM: Anthropic's Claude implementation only supports
+            # a single system message. Multiple system messages will be
+            # combined into one.
+            shared_prompt = prompts.join("\n---\n")
+            chat.messages.create!(
+              role: :system,
+              content_raw: [
+                {
+                  "type" => "text",
+                  "text" => shared_prompt,
+                  "cache_control" => { "type" => "ephemeral" }
+                }
+              ]
+            )
+          end
+        }
+      end
+      end
+    end
+  end
+end

data/lib/agent_c/batch.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module AgentC
+  class Batch
+    def initialize(
+      store:,
+      workspace: nil,
+      repo: nil,
+      session:,
+      record_type:,
+      pipeline:,
+      git: ->(dir) { Utils::Git.new(dir) }
+    )
+      # for context
+      @store_config = store
+      @workspace_config = workspace
+      @repo_config = repo
+      @session_config = session
+
+      # for Batch
+      @record_type = record_type
+      @pipeline_class = pipeline
+      @git = git
+    end
+
+    def call(&)
+      processor.call(&)
+    end
+
+    def add_task(record)
+      processor.add_task(record, @record_type)
+    end
+
+    def abort!
+      processor.abort!
+    end
+
+    def report
+      out = StringIO.new
+
+      tasks = store.task.all
+      succeeded_count = tasks.count { |task| task.done? }
+      pending_count = tasks.count { |task| task.pending? }
+      failed_count = tasks.count { |task| task.failed? }
+
+      out.puts "Succeeded: #{succeeded_count}"
+      out.puts "Pending: #{pending_count}"
+      out.puts "Failed: #{failed_count}"
+
+      cost_data = session.cost
+      out.puts "Run cost: $#{'%.2f' % cost_data.run}"
+      out.puts "Project total cost: $#{'%.2f' % cost_data.project}"
+
+      if failed_count > 0
+        out.puts "\nFirst #{[failed_count, 3].min} failed task(s):"
+        tasks.select { |task| task.failed? }.first(3).each do |task|
+          out.puts "- #{task.error_message}"
+        end
+      end
+
+      out.string
+    end
+
+    def store
+      context.store
+    end
+
+    def workspaces
+      context.workspaces
+    end
+
+    def session
+      context.session
+    end
+
+    private
+
+    def processor
+      @processor ||= Processor.new(
+        context:,
+        handlers: {
+          @record_type => ->(task) {
+            @pipeline_class.call(
+              session:,
+              task:,
+              git: @git
+            )
+          }
+        }
+      )
+    end
+
+    def context
+      @context ||= Context.new(
+        store: @store_config,
+        session: @session_config,
+        workspace: @workspace_config,
+        repo: @repo_config,
+      )
+    end
+  end
+end

data/lib/agent_c/configs/repo.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module AgentC
+  module Configs
+    class Repo
+      attr_reader(
+        :dir,
+        :initial_revision,
+        :working_subdir,
+        :worktrees_root_dir,
+        :worktree_branch_prefix,
+        :worktree_envs,
+        :logger,
+      )
+      def initialize(
+        dir:,
+        initial_revision:,
+        working_subdir: "",
+        worktrees_root_dir:,
+        worktree_branch_prefix:,
+        worktree_envs:,
+        logger:
+      )
+        @dir = dir
+        @initial_revision = initial_revision
+        @working_subdir = working_subdir
+        @worktrees_root_dir = worktrees_root_dir
+        @worktree_branch_prefix = worktree_branch_prefix
+        @worktree_envs = worktree_envs
+        @logger = logger
+      end
+
+      def workspaces(store)
+        git = Utils::Git.new(dir)
+        logger.info("Checking worktrees")
+
+        worktree_configs.map { |spec|
+          worktree_dir = spec.fetch(:dir)
+
+          if store.workspace.where(dir: spec.fetch(:workspace_dir)).exists?
+            logger.info("worktree record exists at #{worktree_dir}, not creating/resetting worktree")
+          else
+            logger.info("creating/resetting worktree at: #{worktree_dir}")
+            git.create_worktree(
+              worktree_dir: worktree_dir,
+              branch: spec.fetch(:branch),
+              revision: initial_revision,
+            )
+          end
+
+          store
+            .workspace
+            .ensure_created!(
+              dir: spec.fetch(:workspace_dir),
+              env: spec.fetch(:env)
+            )
+        }.tap { logger.info("done checking worktrees")}
+      end
+
+      private
+
+      def create_worktrees(store)
+      end
+
+      def workspace_configs
+        worktree_configs.map { _1.slice(:env, :dir) }
+      end
+
+      private
+
+      def worktree_configs
+        @envs_with_paths ||= (
+          worktree_envs
+            .each_with_index
+            .map { |env, i|
+              branch = "#{worktree_branch_prefix}-#{i}"
+              dir = File.join(worktrees_root_dir, branch)
+
+              {
+                env:,
+                dir: ,
+                branch:,
+                workspace_dir: File.join(dir, working_subdir)
+              }
+            }
+        )
+      end
+    end
+  end
+end

data/lib/agent_c/context.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module AgentC
+  class Context
+    attr_reader :config
+    def initialize(store:, session:, repo: nil, workspace: nil)
+      raise ArgumentError.new("must pass workspace or repo") unless workspace || repo
+
+      @store_config = store
+      @session_config = session
+      @workspace_config = workspace
+      @repo_config = repo
+    end
+
+    def store
+      @store ||= (
+        if @store_config.is_a?(Hash)
+          @store_config.fetch(:class).new(**@store_config.fetch(:config))
+        else
+          @store_config
+        end
+      )
+    end
+
+    def workspace
+      raise "Multiple workspaces configured" unless workspaces.count == 1
+
+      workspaces.first
+    end
+
+    def workspaces
+      @workspaces ||= (
+        if @workspace_config.is_a?(Hash)
+          [store.workspace.ensure_created!(**@workspace_config)]
+        elsif @repo_config
+          # Note: This method provision the worktrees if they don't exist
+          Configs::Repo.new(logger: session.logger, **@repo_config).workspaces(store)
+        elsif @workspace_config.is_a?(Array)
+          @workspace_config
+        else
+          [@workspace_config]
+        end
+      )
+    end
+
+    def session
+      @session ||= (
+        if @session_config.is_a?(Hash)
+          Session.new(**@session_config)
+        else
+          @session_config
+        end
+      )
+    end
+  end
+end

data/lib/agent_c/costs/data.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module AgentC
+  module Costs
+    class Data
+      attr_reader :project, :run
+
+      def initialize(project:, run:)
+        @project = project
+        @run = run
+      end
+
+      def self.calculate(agent_store:, project:, run_id: nil)
+        calculator = Report::Calculator.new
+
+        # Calculate project-level cost
+        project_messages = agent_store.message
+          .joins(:chat)
+          .where(chats: { project: project })
+          .includes(:model, :chat)
+        project_stats = calculator.calculate(project_messages)
+        project_cost = project_stats[:total_cost]
+
+        # Calculate run-level cost
+        run_cost = 0.0
+        if run_id
+          run_messages = agent_store.message
+            .joins(:chat)
+            .where(chats: { project: project, run_id: run_id })
+            .includes(:model, :chat)
+          run_stats = calculator.calculate(run_messages)
+          run_cost = run_stats[:total_cost]
+        end
+
+        new(project: project_cost, run: run_cost)
+      end
+    end
+  end
+end