actionagent 1.9.2 → 1.9.3

data/app/services/action_agent/slack_tools.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module ActionAgent
+  # The slack capability: reading channels and posting as the workspace's bot,
+  # through the Slack Web API with the bot token the owner connected in
+  # Settings -> Integrations (a ProviderKey of provider "slack"). Results and
+  # errors are hashes for the model to read; the token never appears in them.
+  class SlackTools
+    FUNCTIONS = %w[slack_list_channels slack_read_channel slack_post_message].freeze
+    API = "https://slack.com/api/"
+    TIMEOUT_SECONDS = 10
+    MAX_CHANNELS = 200
+    MAX_MESSAGES = 50
+
+    NOT_CONNECTED = "Slack is not connected: add a bot token (xoxb-…) in Settings -> Integrations -> Slack"
+
+    def self.function?(name)
+      FUNCTIONS.include?(name.to_s)
+    end
+
+    # The bot token +owner+ connected, or nil.
+    def self.token_for(owner)
+      ProviderKey.for_owner(owner).find_by(provider: "slack")&.credential.presence
+    end
+
+    # @param token [String, nil]
+    def initialize(token)
+      @token = token
+    end
+
+    # @return [Hash]
+    def call(name, kwargs)
+      return { error: "Unknown tool: #{name}" } unless self.class.function?(name)
+      return { error: NOT_CONNECTED } if @token.blank?
+
+      args = kwargs.to_h.symbolize_keys
+      case name.to_s
+      when "slack_list_channels" then list_channels
+      when "slack_read_channel" then read_channel(**args.slice(:channel, :limit))
+      when "slack_post_message" then post_message(**args.slice(:channel, :text, :thread_ts))
+      end
+    end
+
+    def list_channels
+      body = request("conversations.list", { types: "public_channel,private_channel", exclude_archived: true, limit: MAX_CHANNELS })
+      return body if body[:error]
+
+      channels = Array(body["channels"]).map do |channel|
+        { id: channel["id"], name: channel["name"], is_member: channel["is_member"], topic: channel.dig("topic", "value").presence }.compact
+      end
+      { channels: channels }
+    end
+
+    def read_channel(channel:, limit: nil)
+      count = (limit || 20).to_i.clamp(1, MAX_MESSAGES)
+      body = request("conversations.history", { channel: channel.to_s, limit: count })
+      return body if body[:error]
+
+      messages = Array(body["messages"]).map do |message|
+        { ts: message["ts"], user: message["user"] || message["bot_id"], text: message["text"], thread_ts: message["thread_ts"] }.compact
+      end
+      { channel: channel, messages: messages }
+    end
+
+    def post_message(channel:, text:, thread_ts: nil)
+      return { error: "No text to post" } if text.to_s.strip.empty?
+
+      body = request("chat.postMessage", { channel: channel.to_s, text: text.to_s, thread_ts: thread_ts.presence }.compact, post: true)
+      return body if body[:error]
+
+      { posted: true, channel: body["channel"], ts: body["ts"] }
+    end
+
+    private
+
+    # Slack answers 200 with { ok: false, error: } for most failures.
+    def request(method, params, post: false)
+      uri = URI.join(API, method)
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: true, open_timeout: TIMEOUT_SECONDS, read_timeout: TIMEOUT_SECONDS) do |http|
+        headers = { "Authorization" => "Bearer #{@token}", "User-Agent" => "ActiveAgents-Toolbox/1.0" }
+        if post
+          http.post(uri.path, params.to_json, headers.merge("Content-Type" => "application/json; charset=utf-8"))
+        else
+          uri.query = URI.encode_www_form(params)
+          http.get(uri.request_uri, headers)
+        end
+      end
+
+      body = JSON.parse(response.body.to_s)
+      return { error: "Slack refused #{method}: #{body['error'] || "HTTP #{response.code}"}" } unless body["ok"]
+
+      body
+    rescue JSON::ParserError
+      { error: "Slack answered #{method} with something other than JSON (HTTP #{response&.code})" }
+    rescue Net::OpenTimeout, Net::ReadTimeout, SocketError, SystemCallError, OpenSSL::SSL::SSLError => e
+      { error: "Could not reach Slack: #{e.message}" }
+    end
+  end
+end

data/config/routes.rb

@@ -29,8 +29,13 @@ ActionAgent::Engine.routes.draw do
 
     # The collector for evaluation reports an application ran itself
     # (ActiveAgent::Evals::Publisher), at <mount>/api/evaluation_reports.
-    # Authenticated like trace ingest, with a bearer token.
+    # Authenticated like trace ingest, with a bearer token. GET
+    # <mount>/api/evaluation_reports/:run_id exports a stored run in the
+    # envelope the collector takes. A run_id may hold dots, so the path has
+    # no format extension.
     resources :evaluation_reports, only: [ :create ]
+    get "evaluation_reports/:run_id", to: "evaluation_reports#show", as: :evaluation_report,
+                                      constraints: { run_id: %r{[^/]+} }, format: false
 
     post "feedback", to: "feedback_ingest#create"
     get "feedback", to: "feedbacks#index"
@@ -59,6 +64,8 @@ ActionAgent::Engine.routes.draw do
       end
       collection do
         get :presets
+        # The builder's roster for an agent not created yet.
+        get :tool_roster, action: :new_tool_roster
       end
     end
 
@@ -101,6 +108,8 @@ ActionAgent::Engine.routes.draw do
       resources :code_sessions, only: [ :index, :create, :show ] do
         member do
           post :cancel
+          # Another turn of the session's conversation.
+          post :messages
         end
       end
       resource :claude_login, only: [ :show, :create, :destroy ], controller: "claude_logins" do

data/lib/action_agent/engine.rb

@@ -80,6 +80,12 @@ module ActionAgent
       app.config.filter_parameters += [ :credential, :api_key, :access_token, :password, :claude_login_code, /\Arecording_events\z/, /(?:\A|\.)(?:answer|value)\z/i ]
     end
 
+    # Evaluation run reports are served as Markdown (`report.md`). Rails
+    # registers text/markdown as :md from 7.1; an older host gets it here.
+    initializer "action_agent.markdown_mime_type" do
+      Mime::Type.register "text/markdown", :md, [], %w[md markdown] unless Mime[:md]
+    end
+
     # The project setup assistant's request_secret answers go to its
     # handler. Registered on every reload, so the handler is always the
     # current class's.

data/lib/action_agent/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActionAgent
-  VERSION = "1.9.2"
+  VERSION = "1.9.3"
 end

data/lib/action_agent.rb

@@ -111,6 +111,9 @@ module ActionAgent
   # What ActionAgent.claude_code_auth may be set to.
   CLAUDE_CODE_AUTH_MODES = %i[api_key local_login sandbox_login].freeze
 
+  # What ActionAgent.codex_auth may be set to.
+  CODEX_AUTH_MODES = %i[api_key local_login].freeze
+
   # What ActionAgent.provider_key_scope may be set to.
   PROVIDER_KEY_SCOPES = %i[organization personal_override].freeze
 
@@ -134,6 +137,9 @@ module ActionAgent
   #                           they are handed to, or delete a project that has
   #                           them
   #   :take_over_browser      drive a run's browser by hand
+  #   :chat_code_session      send a message to a Claude Code or Codex
+  #                           conversation someone may have started (the
+  #                           subject is its first session)
   #   :manage_recordings      delete a session recording
   #   :replace_scenarios      replace or merge an evaluation's scenarios
   PERMISSION_ACTIONS = %i[
@@ -144,6 +150,7 @@ module ActionAgent
     answer_input_request
     manage_project_secrets
     take_over_browser
+    chat_code_session
     manage_recordings
     replace_scenarios
   ].freeze
@@ -589,10 +596,35 @@ module ActionAgent
     # @return [Integer]
     attr_accessor :claude_code_timeout
 
-    # Codex CLI sessions use the owner's OpenAI API key and workspace-write
-    # sandboxing. They share checkout lifecycle and cancellation with Claude.
+    # Codex CLI sessions run with workspace-write sandboxing, and share the
+    # checkout lifecycle and cancellation with Claude Code.
     attr_accessor :codex_command, :codex_timeout
 
+    # How Codex sessions authenticate.
+    #
+    # :api_key (the default) runs them on the OpenAI API key the owner
+    # connected in Settings -> Integrations, handed to the session as
+    # CODEX_API_KEY with a Codex home of the sandbox's own. Usage is billed
+    # to that key's project.
+    #
+    # :local_login runs `codex` on whatever login this machine's user set up
+    # with `codex login` (a ChatGPT plan, or a key given to the CLI), which
+    # Codex keeps under ~/.codex. The dashboard never reads, copies or
+    # stores it; it only asks `codex login status` whether there is one.
+    # That login is the dashboard user's own, so this works with the :local
+    # sandbox backend only, and other backends refuse Codex sessions.
+    # @return [Symbol] :api_key or :local_login
+    attr_reader :codex_auth
+
+    def codex_auth=(value)
+      mode = value.to_s.to_sym
+      unless CODEX_AUTH_MODES.include?(mode)
+        raise ArgumentError, "ActionAgent.codex_auth must be :api_key or :local_login, not #{value.inspect}"
+      end
+
+      @codex_auth = mode
+    end
+
     # How Claude Code sessions authenticate.
     #
     # :api_key (the default) runs them on the Anthropic API key the owner
@@ -1248,6 +1280,7 @@ module ActionAgent
       @claude_code_timeout = 1800
       @codex_command = "codex"
       @codex_timeout = 1800
+      @codex_auth = :api_key
       @claude_code_auth = :api_key
       @claude_code_hosted_login_enabled = false
       @claude_code_login_timeout = 300

data/lib/generators/action_agent/templates/migrations/028_add_conversations_to_code_sessions.rb.erb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Makes Claude Code and Codex sessions conversations: each session is one
+# turn, and a turn after the first names the conversation's first session as
+# its root. A conversation resumes the same CLI session (resume_session_id),
+# and a turn may carry a note from the dashboard ahead of the person's
+# message (context_note), such as who drove the browser since the last turn.
+class AddConversationsToCodeSessions < ActiveRecord::Migration<%= migration_version %>
+  def change
+    sessions = "#{ActionAgent.table_name_prefix}code_sessions"
+    add_column sessions, :conversation_root_id, :bigint
+    add_column sessions, :turn_index, :integer, default: 0, null: false
+    add_column sessions, :origin, :string
+    add_column sessions, :context_note, :text
+    add_column sessions, :resume_session_id, :string
+    add_index sessions, :conversation_root_id
+  end
+end

data/lib/tasks/evaluations.rake

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# Evaluation run reports from the command line: a run out as the version-1
+# envelope the evaluation report collector takes (or as its HTML report page,
+# or as GitHub-flavored Markdown for a pull request), and an envelope in
+# through the collector's own import. On a multi-tenant install name the
+# tenant with ACCOUNT_ID=<id>.
+#
+#   bin/rails action_agent:evaluations:export RUN=dashboard-run-12-20261021093000 FILE=tmp/run.json
+#   bin/rails action_agent:evaluations:export EVALUATION=3 RUN=12 FORMAT=html FILE=tmp/run.html
+#   bin/rails action_agent:evaluations:export EVALUATION=3 RUN=12 FORMAT=md > tmp/run.md
+#   bin/rails action_agent:evaluations:import FILE=tmp/run.json
+namespace :action_agent do
+  namespace :evaluations do
+    desc "Write a run's report (RUN=run_id, or EVALUATION=id RUN=id; FORMAT=json|html|md; FILE=path, standard output without FILE)"
+    task export: :environment do
+      run = action_agent_evaluation_run!
+      export = ActionAgent::EvaluationReportExport.new(run)
+      format = ENV.fetch("FORMAT", "json").downcase
+      body =
+        case format
+        when "json" then export.to_json
+        when "html" then run.to_report.to_html
+        when "md", "markdown" then export.markdown
+        else abort "FORMAT is json, html or md"
+        end
+
+      if ENV["FILE"].present?
+        File.write(ENV["FILE"], body)
+        puts "Wrote run #{export.run_id} of #{run.evaluation.name} (#{format}) to #{ENV['FILE']}"
+      else
+        puts body
+      end
+    rescue ActionAgent::EvaluationReportExport::NotExportable => e
+      abort "Export refused: #{e.message}"
+    end
+
+    desc "Store a version-1 evaluation report envelope (FILE=path [ACCOUNT_ID=id]); importing it again changes nothing"
+    task import: :environment do
+      path = ENV.fetch("FILE") { abort "Name the file: FILE=tmp/run.json" }
+      abort "No file at #{path}" unless File.file?(path)
+      abort "Unavailable: #{ActionAgent::EvaluationReportImport.unavailable_reason}" if ActionAgent::EvaluationReportImport.unavailable_reason
+
+      account = action_agent_evaluation_account
+      run, duplicate = ActionAgent::EvaluationReportImport.call(account: account, payload: JSON.parse(File.read(path)))
+      ActionAgent.record_usage(account, :evaluation_report) unless duplicate
+      puts "#{duplicate ? 'Already stored (identical retry)' : 'Stored'}: run #{ActionAgent::EvaluationReportExport.run_id_for(run)} " \
+           "as run ##{run.id} of evaluation ##{run.evaluation_id} (#{run.evaluation.name}), #{run.status}"
+    rescue JSON::ParserError
+      abort "Import refused: #{path} is not JSON"
+    rescue ActionAgent::EvaluationReportImport::Error, ActiveRecord::RecordInvalid => e
+      abort "Import refused: #{e.message}"
+    end
+  end
+end
+
+# The tenant, from ACCOUNT_ID (ACCOUNT also works); nil on a single-tenant
+# install.
+def action_agent_evaluation_account
+  id = ENV["ACCOUNT_ID"].presence || ENV["ACCOUNT"].presence
+  return nil unless id
+
+  abort "ACCOUNT_ID names a tenant, which only a multi-tenant install has" unless ActionAgent.multi_tenant?
+  ActionAgent.account_class.to_s.constantize.find_by(id: id) || abort("No account #{id}")
+end
+
+# The run RUN names: with EVALUATION, a run id of that evaluation; without,
+# a run_id as the export endpoint takes it, within the tenant.
+def action_agent_evaluation_run!
+  run_id = ENV.fetch("RUN") { abort "Name the run: RUN=<run_id>, or EVALUATION=<id> RUN=<id>" }
+  if ENV["EVALUATION"].present?
+    evaluation = ActionAgent::Evaluation.find_by(id: ENV["EVALUATION"]) || abort("No evaluation #{ENV['EVALUATION']}")
+    evaluation.evaluation_runs.find_by(id: run_id) || abort("No run #{run_id} in evaluation #{evaluation.id}")
+  else
+    ActionAgent::EvaluationReportExport.find(run_id, account: action_agent_evaluation_account) ||
+      abort("No run with run_id #{run_id.inspect}#{' for that account' if ENV['ACCOUNT_ID'].present? || ENV['ACCOUNT'].present?}")
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: actionagent
 version: !ruby/object:Gem::Version
-  version: 1.9.2
+  version: 1.9.3
 platform: ruby
 authors:
 - Justin Bowen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-20 00:00:00.000000000 Z
+date: 2026-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activeagent
@@ -246,7 +246,9 @@ files:
 - app/models/concerns/action_agent/session_recordable.rb
 - app/queries/action_agent/agent_executions.rb
 - app/queries/action_agent/metrics_report.rb
+- app/queries/action_agent/trace_window_report.rb
 - app/serializers/action_agent/agent_message_serializer.rb
+- app/serializers/action_agent/code_conversation_serializer.rb
 - app/serializers/action_agent/evaluation_serializer.rb
 - app/serializers/action_agent/input_request_serializer.rb
 - app/serializers/action_agent/interaction_preview.rb
@@ -261,17 +263,23 @@ files:
 - app/services/action_agent/agent_sync.rb
 - app/services/action_agent/agent_tool_roster.rb
 - app/services/action_agent/agent_toolbox.rb
+- app/services/action_agent/browser_client_token.rb
 - app/services/action_agent/browser_live_ticket.rb
 - app/services/action_agent/browser_sidecar.rb
 - app/services/action_agent/browser_sign_in.rb
 - app/services/action_agent/browser_tool_redaction.rb
+- app/services/action_agent/checkout_tools.rb
 - app/services/action_agent/claude_code_auth.rb
+- app/services/action_agent/code_conversation.rb
+- app/services/action_agent/codex_auth.rb
 - app/services/action_agent/codex_session_events.rb
 - app/services/action_agent/dashboard_assistant_service.rb
+- app/services/action_agent/diff_stat.rb
 - app/services/action_agent/draft_pull_request_publisher.rb
 - app/services/action_agent/evaluation_evidence.rb
 - app/services/action_agent/evaluation_fix.rb
 - app/services/action_agent/evaluation_fix_comparison.rb
+- app/services/action_agent/evaluation_report_export.rb
 - app/services/action_agent/evaluation_report_import.rb
 - app/services/action_agent/evaluation_run_cost.rb
 - app/services/action_agent/evaluation_runner_service.rb
@@ -316,6 +324,7 @@ files:
 - app/services/action_agent/session_index.rb
 - app/services/action_agent/session_recording_service.rb
 - app/services/action_agent/session_timeline.rb
+- app/services/action_agent/slack_tools.rb
 - app/services/action_agent/tool_discovery.rb
 - app/views/action_agent/dashboard/index.html.erb
 - app/views/action_agent/github_app_manifests/created.html.erb
@@ -360,9 +369,11 @@ files:
 - lib/generators/action_agent/templates/migrations/025_create_active_agent_scenario_catalogs.rb.erb
 - lib/generators/action_agent/templates/migrations/026_add_evaluation_fixes_to_code_sessions.rb.erb
 - lib/generators/action_agent/templates/migrations/027_create_active_agent_interaction_feedbacks.rb.erb
+- lib/generators/action_agent/templates/migrations/028_add_conversations_to_code_sessions.rb.erb
 - lib/tasks/action_agent.rake
 - lib/tasks/browser.rake
 - lib/tasks/claude_code.rake
+- lib/tasks/evaluations.rake
 - lib/tasks/sandbox.rake
 - lib/tasks/scenario_catalogs.rake
 homepage: https://activeagents.ai