agent_c 2.9

data/lib/agent_c/pipelines/agent.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module AgentC
+  module Pipelines
+    class Agent
+      attr_reader :pipeline
+      def initialize(pipeline)
+        @pipeline = pipeline
+      end
+
+      def agent_review_loop(
+        name,
+        max_tries: 10,
+        implement: [],
+        iterate: implement,
+        review:
+      )
+        implement = Array(implement)
+        iterate = Array(iterate)
+        review = Array(review)
+
+        unless implement.any? || iterate.any?
+          raise ArgumentError.new("Must pass implement or iterate prompts")
+        end
+
+        tries = 0
+        review_passed = false
+        feedbacks = []
+
+        while(tries < max_tries && !review_passed && !task.failed?)
+          if tries == 0
+            implement.each do |name|
+              apply_prompt(name)
+              break if task.failed?
+            end
+          else
+            iterate.each do |name|
+              apply_prompt(
+                name,
+                additional_i18n_attributes: {
+                  feedback: feedbacks.join("\n---\n")
+                }
+              )
+              break if task.failed?
+            end
+          end
+
+          tries += 1
+
+          unless task.failed?
+            feedbacks = []
+            diff = git.diff
+            review.each do |name|
+              params = i18n_params(
+                name,
+                additional_i18n_attributes: {
+                  diff:
+                },
+              ).merge(
+                schema: -> {
+                  boolean(:approved)
+                  string(:feedback)
+                },
+              )
+
+              result = prompt(name, **params)
+
+              if result.success?
+                if !result.data.fetch("approved")
+                  feedbacks << result.data.fetch("feedback")
+                end
+              else
+                task.fail!(result.error_message)
+              end
+            end
+
+            if record.respond_to?(:add_review)
+              record.add_review(diff:, feedbacks:)
+            end
+
+            review_passed = feedbacks.empty?
+          end
+        end
+      end
+
+      def agent_step(name, **params, &block)
+        apply_prompt(name, **params, &block)
+      end
+
+      private
+
+      def record
+        pipeline.record
+      end
+
+      def task
+        pipeline.task
+      end
+
+      def workspace
+        pipeline.workspace
+      end
+
+      def session
+        pipeline.session
+      end
+
+      def git
+        pipeline.git
+      end
+
+      def apply_prompt(...)
+        result = prompt(...)
+
+        if result.success?
+          task.record.update!(result.data)
+        else
+          task.fail!(result.error_message)
+        end
+      end
+
+      def prompt(
+        name,
+        additional_i18n_attributes: {},
+        **params,
+        &block
+      )
+        resolved_params = (
+          if block
+            instance_exec(&block)
+          elsif params.empty?
+            i18n_params(name, additional_i18n_attributes:)
+          else
+            i18n_attributes = (
+              if record.respond_to?(:i18n_attributes)
+                record.i18n_attributes
+              else
+                record.attributes
+              end
+            ).merge(additional_i18n_attributes)
+
+            {
+              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
+        )
+
+        session.prompt(
+          on_chat_created: -> (id) { task.chat_ids << id},
+          **resolved_params
+        )
+      end
+
+      def i18n_params(name, additional_i18n_attributes: {})
+        i18n_attributes = (
+          if record.respond_to?(:i18n_attributes)
+            record.i18n_attributes
+          else
+            record.attributes
+          end
+        ).merge(additional_i18n_attributes)
+
+        {
+          tool_args: {
+            workspace_dir: workspace.dir,
+            env: workspace.env,
+          },
+          cached_prompt: (
+            if I18n.exists?("#{name}.cached_prompts")
+              I18n.t("#{name}.cached_prompts")
+            else
+              []
+            end
+          ),
+          prompt: I18n.t("#{name}.prompt", **i18n_attributes.symbolize_keys),
+          tools: (
+            if I18n.exists?("#{name}.tools")
+              I18n.t("#{name}.tools")
+            else
+              []
+            end
+          ),
+          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
+          }
+        }
+      rescue => e
+        binding.irb
+      end
+    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(handler.task) 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

data/lib/agent_c/prompts.yml

@@ -0,0 +1,53 @@
+en:
+  agent:
+    chat:
+      refine:
+        system_message: |
+          ---BEGIN-SYSTEM-MESSAGE---
+          Hello, this conversation is currently being "refined". That means,
+          this prompt was already asked to an AI and an answer was received.
+
+          The user is requesting that you "refine" the answer given by the
+          prior AI conversation. Your goal is to review the prior answer,
+          evaluate its accuracy. If you determine that some changes should be
+          made, then adjust the answer and respond with the corrected version.
+          It is possible that the prior answer is accurate and acceptable. In
+          that case, simply respond with the prior answer as-is.
+
+          Here is the answer previously given to this prompt:
+
+          ---BEGIN-PRIOR-ANSWER---
+          %{prior_answer}
+          ---END-PRIOR-ANSWER---
+          ---END-SYSTEM-MESSAGE---
+
+          %{original_message}
+      get_result:
+        json_instructions: |
+          Your response will be parsed as JSON directly by passing it to JSON.parse.
+
+          DO NOT add any commentary to the JSON response.
+          DO NOT format your response as markdown
+          DO NOT begin your response with "```" OR "```json"
+
+          YOUR RESPONSE SHOULD BE PURE JSON AND BEGIN WITH ONE OF THE FOLLOWING: {["
+        schema_requirement: |
+          Your answer to the following request must be JSON that adheres to
+          the following schema.
+
+          ---BEGIN-JSON-SCHEMA---
+          %{json_schema}
+          ---END-JSON-SCHEMA---
+        request_wrapper: |
+          ---BEGIN-REQUEST---
+          %{msg}
+          ---END-REQUEST---
+        schema_validation_error: |
+          Your response did not adhere to the given schema. Its errors:
+          %{errors}
+        json_parse_error: |
+          Your response failed to parse as JSON. RESPOND WITH ONLY VALID JSON
+          NOTHING ELSE.
+  task_1:
+    pending: |
+      Translate the word "%{word}" to %{language}.

data/lib/agent_c/schema.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "ruby_llm/schema"
+
+module AgentC
+  module Schema
+    class AnyOneOf
+      attr_reader :schemas
+      def initialize(*schemas)
+        @schemas = schemas
+      end
+
+      def to_nested_schema
+        to_json_schema.fetch(:schema).fetch(:oneOf)
+      end
+
+      def schema_jsons
+        @schema_jsons ||= (
+          schemas.flat_map do |schema|
+            if schema.is_a?(AnyOneOf)
+              to_nested_schema
+            elsif schema.is_a?(Hash)
+              schema
+            elsif schema.ancestors.include?(RubyLLM::Schema)
+              schema.new.to_json_schema.fetch(:schema)
+            else
+              raise ArgumentError, "Invalid schema class: #{schema}"
+            end
+          end
+        )
+      end
+
+      def to_json_schema
+        {
+          schema: {
+            oneOf: schema_jsons
+          }
+        }
+      end
+    end
+
+    class ErrorSchema < RubyLLM::Schema
+      string(
+        :unable_to_fulfill_request_error,
+        description: <<~TXT
+          Only fill out this field if you are unable to perform the requested
+          task and/or unable to fulfill the other schema provided.
+
+          Fill this in a clear message indicating why you were unable to fulfill
+          the request.
+        TXT
+      )
+    end
+
+    def self.result(schema: nil, &)
+      # Create the success schema
+      success_schema = (
+        if block_given? || schema&.respond_to?(:call)
+          Class.new(RubyLLM::Schema) do
+            instance_exec(&) if block_given?
+            instance_exec(&schema) if schema
+          end
+        else
+          schema
+        end
+      )
+
+      AnyOneOf.new(success_schema, ErrorSchema)
+    end
+  end
+end

data/lib/agent_c/session.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module AgentC
+  class Session
+    Configuration = Data.define(
+      :agent_db_path,
+      :logger,
+      :i18n_path,
+      :workspace_dir,
+      :project,
+      :run_id,
+      :max_spend_project,
+      :max_spend_run,
+      :extra_tools,
+    )
+
+    attr_reader :logger
+
+    def initialize(
+      agent_db_path:,
+      project:,
+      logger: Logger.new("/dev/null"),
+      workspace_dir: Dir.pwd,
+      run_id: Time.now.to_i,
+      i18n_path: nil,
+      max_spend_project: nil,
+      max_spend_run: nil,
+      ruby_llm: {},
+      extra_tools: {},
+      chat_provider: ->(**params) { create_chat(**params) }
+    )
+      @agent_db_path = agent_db_path
+      @project = project
+      @logger = logger
+      @workspace_dir = workspace_dir
+      @run_id = run_id
+      @i18n_path = i18n_path
+      @max_spend_project = max_spend_project
+      @max_spend_run = max_spend_run
+      @ruby_llm = ruby_llm
+
+      unless extra_tools.is_a?(Hash)
+        raise ArgumentError, "extra_tools must be a hash mapping name to class or instance"
+      end
+      @extra_tools = extra_tools
+
+      @chat_provider = chat_provider
+
+      unless agent_db_path.match(/.sqlite3?$/)
+        raise ArgumentError, "agent_db_path must end with '.sqlite3' or '.sqlite'"
+      end
+
+      # Load i18n path if provided
+      if i18n_path
+        I18n.load_path << i18n_path
+      end
+    end
+
+    def chat(
+      tools: Tools::NAMES.keys,
+      cached_prompts: [],
+      workspace_dir: nil,
+      record: nil
+    )
+      @chat_provider.call(
+        tools: tools,
+        cached_prompts: cached_prompts,
+        workspace_dir: workspace_dir || config.workspace_dir,
+        record: record,
+        session: self
+      )
+    end
+
+    def prompt(
+      tool_args: {},
+      tools: Tools::NAMES.keys + config.extra_tools.keys,
+      cached_prompt: [],
+      prompt:,
+      schema:,
+      on_chat_created: ->(*) {}
+    )
+      workspace_dir = tool_args[:workspace_dir] || config.workspace_dir
+
+      resolved_tools = (
+        tools
+          .map { |value|
+            Tools.resolve(
+              value:,
+              available_tools: Tools::NAMES.merge(config.extra_tools),
+              args: tool_args,
+              workspace_dir: config.workspace_dir
+            )
+          }
+      )
+
+      chat_instance = chat(
+        tools: resolved_tools,
+        cached_prompts: cached_prompt,
+        workspace_dir: workspace_dir
+      )
+      on_chat_created.call(chat_instance.id)
+
+      message = Array(prompt).join("\n")
+
+      begin
+        result = chat_instance.get(message, schema: Schema.result(&schema))
+
+        Agent::ChatResponse.new(
+          chat_id: chat_instance.id,
+          raw_response: result,
+        )
+      rescue => e
+        Agent::ChatResponse.new(
+          chat_id: chat_instance.id,
+          raw_response: {
+            "unable_to_fulfill_request_error" => ["#{e.class.name}:#{e.message}", e.backtrace].join("\n")
+          },
+        )
+      end
+    end
+
+    def config
+      @config ||= Configuration.new(
+        agent_db_path: @agent_db_path,
+        logger: @logger,
+        i18n_path: @i18n_path,
+        workspace_dir: @workspace_dir,
+        project: @project,
+        run_id: @run_id,
+        max_spend_project: @max_spend_project,
+        max_spend_run: @max_spend_run,
+        extra_tools: @extra_tools,
+      )
+    end
+
+    def ruby_llm_context
+      @ruby_llm_context ||= RubyLLM.context do |ctx_config|
+        @ruby_llm.each do |key, value|
+          ctx_config.public_send("#{key}=", value)
+        end
+        ctx_config.use_new_acts_as = true
+      end
+    end
+
+    def agent_store
+      @agent_store ||= Db::Store.new(
+        path: @agent_db_path,
+        logger: @logger,
+        versioned: false
+      )
+    end
+
+    def cost
+      Costs::Data.calculate(
+        agent_store: agent_store,
+        project: config.project,
+        run_id: config.run_id
+      )
+    end
+
+    private
+
+    def create_chat(**params)
+      real_record = params[:record] || (
+        Agent::Chats::AnthropicBedrock.create(
+          project: config.project,
+          run_id: config.run_id,
+          prompts: params.fetch(:cached_prompts, []),
+          agent_store:,
+          ruby_llm_context:
+        )
+      )
+
+      real_record.on_end_message do |message|
+        check_abort_cost
+      end
+
+      Agent::Chat.new(
+        **params.except(:record),
+        record: real_record
+      )
+    end
+
+    def check_abort_cost
+      return unless config.max_spend_project || config.max_spend_run
+
+      if config.max_spend_project && cost.project >= config.max_spend_project
+        raise Errors::AbortCostExceeded.new(
+          cost_type: "project",
+          current_cost: cost.project,
+          threshold: config.max_spend_project
+        )
+      end
+
+      if config.max_spend_run && cost.run >= config.max_spend_run
+        raise Errors::AbortCostExceeded.new(
+          cost_type: "run",
+          current_cost: cost.run,
+          threshold: config.max_spend_run
+        )
+      end
+    end
+  end
+end

data/lib/agent_c/store.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module AgentC
+  module Store
+    extend ActiveSupport::Concern
+
+    included do
+      record(:workspace) do
+        schema do |t|
+          t.string(:dir, null: false)
+          t.json(:env, default: [])
+        end
+
+        def self.ensure_created!(dir:, env:)
+          find_or_create_by!(dir:).tap { _1.update!(env:) }
+        end
+      end
+
+      record(:task) do
+        schema do |t|
+          t.string(:status, default: "pending")
+          t.json(:completed_steps, default: [])
+          t.string(:record_type)
+          t.integer(:record_id)
+          t.references(:workspace)
+
+          t.string(:handler)
+
+          t.string(:error_message)
+          t.json(:chat_ids, default: [])
+
+          t.timestamps
+        end
+
+        belongs_to(
+          :record,
+          polymorphic: true,
+          required: false
+        )
+
+        belongs_to(
+          :workspace,
+          class_name: class_name(:workspace),
+          required: false
+        )
+
+        def fail!(message)
+          update!(
+            status: "failed",
+            error_message: message
+          )
+        end
+
+        def done!
+          update!(status: "done")
+        end
+
+        def done?
+          status == "done"
+        end
+
+        def failed?
+          status == "failed"
+        end
+
+        def pending?
+          status == "pending"
+        end
+      end
+    end
+  end
+end