ruby_coded 0.1.1 → 0.2.1

data/lib/ruby_coded/chat/codex_bridge/error_handling.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class CodexBridge
+      # Retry logic and error message formatting for the Codex API client.
+      module ErrorHandling
+        AGENT_SWITCH_PATTERN = /
+          \b(implement|go[ ]ahead|proceed|execut|ejecutar?|comenz|
+          comienz|hazlo|constru[iy]|adelante|dale|do[ ]it|build[ ]it)\b
+        /ix
+
+        private
+
+        def build_connection
+          Faraday.new(url: CODEX_BASE_URL) do |f|
+            f.options.timeout = 300
+            f.options.open_timeout = 30
+          end
+        end
+
+        def reset_call_counts
+          @tool_call_count = 0
+          @write_tool_call_count = 0
+        end
+
+        def prepare_send(input)
+          auto_switch_to_agent! if should_auto_switch_to_agent?(input)
+          reset_call_counts
+          @cancel_requested = false
+          @state.streaming = true
+          @state.add_message(:assistant, "")
+        end
+
+        def should_auto_switch_to_agent?(input)
+          @plan_mode && @state.respond_to?(:current_plan) && @state.current_plan &&
+            input.match?(AGENT_SWITCH_PATTERN)
+        end
+
+        def auto_switch_to_agent!
+          toggle_agentic_mode!(true)
+          @state.add_message(:system,
+                             "Plan mode disabled — switching to agent mode to implement the plan.")
+        end
+
+        def attempt_with_retries(input, retries = 0)
+          perform_codex_request(input)
+        rescue Tools::AgentCancelledError, Tools::AgentIterationLimitError, Tools::ToolRejectedError => e
+          @state.add_message(:system, e.message)
+        rescue CodexAPIError => e
+          @state.fail_last_assistant(e, friendly_message: codex_error_message(e))
+        rescue Faraday::TooManyRequestsError => e
+          retry if (retries = handle_rate_limit_retry(e, retries))
+          @state.fail_last_assistant(e, friendly_message: rate_limit_message(e))
+        rescue StandardError => e
+          @state.fail_last_assistant(e, friendly_message: "Codex API error: #{e.message}")
+        end
+
+        def handle_rate_limit_retry(error, retries)
+          return unless retries < MAX_RATE_LIMIT_RETRIES && !@cancel_requested
+
+          retries += 1
+          delay = RATE_LIMIT_BASE_DELAY * (2**(retries - 1))
+          msg = "Rate limit reached. Retrying in #{delay}s... (#{retries}/#{MAX_RATE_LIMIT_RETRIES})"
+          @state.fail_last_assistant(error, friendly_message: msg)
+          sleep(delay)
+          @state.reset_last_assistant_content
+          retries
+        end
+
+        def codex_error_message(error)
+          case error.status
+          when 401
+            "Authentication failed. Your OAuth session may have expired. " \
+            "Try /login to re-authenticate. (#{error.message})"
+          when 403
+            "Access denied. Your ChatGPT subscription may not include Codex access. (#{error.message})"
+          when 404 then "Codex endpoint not found. The API may have changed. (#{error.message})"
+          when 429 then rate_limit_message(error)
+          else "Codex API error: #{error.message}"
+          end
+        end
+
+        def rate_limit_message(error)
+          <<~MSG.strip
+            ChatGPT usage limit reached. This may be a 5-hour or weekly limit on your Plus/Pro subscription.
+            Wait and try again later. Detail: #{error.message}
+          MSG
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/codex_bridge/request_builder.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class CodexBridge
+      # Builds HTTP requests for the Codex Responses API.
+      module RequestBuilder
+        CODEX_HEADERS_BASE = {
+          "Content-Type" => "application/json",
+          "Accept" => "text/event-stream",
+          "originator" => "codex_cli_rs",
+          "OpenAI-Beta" => "responses=experimental"
+        }.freeze
+
+        DEFAULT_INSTRUCTIONS = "You are a helpful coding assistant. " \
+                               "Answer concisely and provide code examples when relevant."
+
+        private
+
+        def codex_headers
+          credentials = current_credentials
+          account_id = Auth::JWTDecoder.extract_account_id(credentials["access_token"])
+
+          CODEX_HEADERS_BASE.merge(
+            "Authorization" => "Bearer #{credentials["access_token"]}",
+            "chatgpt-account-id" => account_id.to_s
+          )
+        end
+
+        def build_request_body
+          body = base_request_body
+          body[:tools] = build_tools_spec if @agentic_mode || @plan_mode
+          body
+        end
+
+        def base_request_body
+          {
+            model: @model, instructions: build_instructions,
+            input: build_input_array, store: false, stream: true,
+            reasoning: { effort: "medium", summary: "auto" },
+            text: { verbosity: "medium" },
+            include: ["reasoning.encrypted_content"]
+          }
+        end
+
+        def build_input_array
+          @conversation_history.map { |msg| format_history_message(msg) }
+        end
+
+        def format_history_message(msg)
+          case msg[:type]
+          when "function_call" then format_function_call(msg)
+          when "function_call_output" then format_function_output(msg)
+          else { role: msg[:role], content: msg[:content].to_s }
+          end
+        end
+
+        def format_function_call(msg)
+          {
+            type: "function_call", name: msg[:name],
+            arguments: msg[:arguments].is_a?(String) ? msg[:arguments] : msg[:arguments].to_json,
+            call_id: msg[:call_id]
+          }
+        end
+
+        def format_function_output(msg)
+          { type: "function_call_output", call_id: msg[:call_id], output: msg[:output].to_s }
+        end
+
+        def build_instructions
+          if @agentic_mode
+            Tools::SystemPrompt.build(
+              project_root: @project_root, max_write_rounds: MAX_WRITE_TOOL_ROUNDS,
+              max_total_rounds: MAX_TOTAL_TOOL_ROUNDS
+            )
+          elsif @plan_mode
+            Tools::PlanSystemPrompt.build(project_root: @project_root)
+          else
+            DEFAULT_INSTRUCTIONS
+          end
+        end
+
+        def build_tools_spec
+          tool_instances = if @agentic_mode
+                             @tool_registry.build_tools
+                           else
+                             @tool_registry.build_readonly_tools
+                           end
+
+          tool_instances.map { |tool| tool_to_responses_api(tool) }
+        end
+
+        def tool_to_responses_api(tool)
+          {
+            type: "function",
+            name: tool.name,
+            description: tool.description.to_s,
+            parameters: tool.params_schema
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/codex_bridge/sse_parser.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class CodexBridge
+      # Parses Server-Sent Events from the Codex streaming response and
+      # dispatches content deltas, tool calls, and completion signals.
+      module SSEParser
+        StreamContext = Struct.new(
+          :assistant_text, :pending_tool_calls, :buffer, :raw_body, :status, keyword_init: true
+        )
+
+        private
+
+        def perform_codex_request(input)
+          ensure_token_fresh!
+          ctx = StreamContext.new(assistant_text: +"", pending_tool_calls: [], buffer: +"", raw_body: +"", status: nil)
+          execute_streaming_post(ctx)
+          finalize_response(ctx.assistant_text)
+          process_pending_tool_calls(ctx.pending_tool_calls, input) if ctx.pending_tool_calls.any?
+        end
+
+        def execute_streaming_post(ctx)
+          response = post_streaming_request(ctx)
+          ctx.status ||= response.status
+          handle_http_error(ctx.status, ctx.raw_body) unless (200..299).cover?(ctx.status)
+        end
+
+        def post_streaming_request(ctx)
+          @conn.post(CODEX_RESPONSES_PATH) do |req|
+            req.headers = codex_headers
+            req.body = build_request_body.to_json
+            req.options.on_data = proc { |chunk, _size, env| handle_stream_chunk(ctx, chunk, env) }
+          end
+        end
+
+        def handle_stream_chunk(ctx, chunk, env)
+          ctx.status ||= env&.status
+          ctx.raw_body << chunk
+          return if @cancel_requested || (ctx.status && !(200..299).cover?(ctx.status))
+
+          ctx.buffer << chunk
+          process_sse_buffer(ctx.buffer, ctx.assistant_text, ctx.pending_tool_calls)
+        end
+
+        def process_sse_buffer(buffer, assistant_text, pending_tool_calls)
+          while (line_end = buffer.index("\n"))
+            line = buffer.slice!(0, line_end + 1).strip
+            next if line.empty?
+
+            process_sse_line(line, assistant_text, pending_tool_calls)
+          end
+        end
+
+        def process_sse_line(line, assistant_text, pending_tool_calls)
+          return unless line.start_with?("data: ")
+
+          data = line[6..]
+          return if data == "[DONE]"
+
+          event = parse_json(data)
+          return unless event
+
+          dispatch_sse_event(event, assistant_text, pending_tool_calls)
+        end
+
+        def dispatch_sse_event(event, assistant_text, pending_tool_calls)
+          case event["type"]
+          when "response.output_text.delta" then handle_text_delta(event, assistant_text)
+          when "response.function_call_arguments.delta" then handle_function_args_delta(event, pending_tool_calls)
+          when "response.function_call_arguments.done" then handle_function_call_done(event, pending_tool_calls)
+          when "response.output_item.added" then handle_output_item_added(event, pending_tool_calls)
+          end
+        end
+
+        def handle_text_delta(event, assistant_text)
+          delta = event["delta"]
+          return unless delta.is_a?(String) && !delta.empty?
+
+          assistant_text << delta
+          @state.streaming_append(delta)
+        end
+
+        def handle_output_item_added(event, pending_tool_calls)
+          item = event["item"]
+          return unless item && item["type"] == "function_call"
+
+          pending_tool_calls << {
+            call_id: item["call_id"] || item["id"],
+            name: item["name"],
+            arguments: +""
+          }
+        end
+
+        def handle_function_args_delta(event, pending_tool_calls)
+          delta = event["delta"]
+          return unless delta.is_a?(String)
+
+          pending_tool_calls.last&.tap { |c| c[:arguments] << delta }
+        end
+
+        def handle_function_call_done(event, pending_tool_calls)
+          call_id = event["call_id"] || event.dig("item", "call_id")
+          return unless call_id
+
+          tc = pending_tool_calls.find { |c| c[:call_id] == call_id }
+          tc[:arguments] = event["arguments"] || tc[:arguments] if tc
+        end
+
+        def finalize_response(assistant_text)
+          @conversation_history << { role: "assistant", content: assistant_text } unless assistant_text.empty?
+        end
+
+        def handle_http_error(status, body_text)
+          detail = extract_error_detail(body_text)
+          raise CodexAPIError.new(status, detail)
+        end
+
+        def extract_error_detail(body_text)
+          parsed = JSON.parse(body_text)
+          return body_text[0, 300] unless parsed.is_a?(Hash)
+
+          parsed.dig("error", "message") || parsed["detail"] || parsed["message"] || body_text[0, 300]
+        rescue StandardError
+          body_text[0, 300]
+        end
+
+        def parse_json(str)
+          JSON.parse(str)
+        rescue JSON::ParserError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/codex_bridge/token_manager.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class CodexBridge
+      # Manages OAuth token refresh for the Codex bridge.
+      # Checks token expiration before each request and refreshes
+      # via the existing OAuthStrategy/AuthManager infrastructure.
+      module TokenManager
+        TOKEN_REFRESH_BUFFER = 60
+
+        private
+
+        def current_credentials
+          @credentials_store.retrieve(:openai)
+        end
+
+        def ensure_token_fresh!
+          credentials = current_credentials
+          return unless credentials && credentials["auth_method"] == "oauth"
+          return unless token_expired?(credentials)
+
+          refresh_token!(credentials)
+        end
+
+        def token_expired?(credentials)
+          expires_at = credentials["expires_at"]
+          return false unless expires_at
+
+          Time.parse(expires_at) <= Time.now + TOKEN_REFRESH_BUFFER
+        end
+
+        def refresh_token!(credentials)
+          provider = Auth::AuthManager::PROVIDERS[:openai]
+          strategy = Strategies::OAuthStrategy.new(provider)
+          refreshed = strategy.refresh(credentials)
+          @credentials_store.store(:openai, refreshed)
+          @auth_manager&.configure_ruby_llm!
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/codex_bridge/tool_approval.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RubyCoded
+  module Chat
+    class CodexBridge
+      # Manages interactive approval flow for tool calls in agentic mode.
+      module ToolApproval
+        private
+
+        def request_approval(_tool_call, display_name, args, risk)
+          args_summary = args.map { |k, v| "#{k}: #{v}" }.join(", ")
+
+          if risk == Tools::BaseTool::SAFE_RISK || @state.auto_approve_tools?
+            @state.add_message(:tool_call, "[#{display_name}] #{args_summary}")
+          else
+            risk_label = risk == Tools::BaseTool::DANGEROUS_RISK ? "DANGEROUS" : "WRITE"
+            @state.request_tool_confirmation!(display_name, args, risk_label: risk_label)
+            decision = poll_tool_decision
+            apply_tool_decision(decision, display_name)
+          end
+        end
+
+        def poll_tool_decision
+          @state.mutex.synchronize do
+            loop do
+              return :cancelled if @cancel_requested
+
+              resp = @state.instance_variable_get(:@tool_confirmation_response)
+              return resp if %i[approved rejected].include?(resp)
+
+              @state.tool_cv.wait(@state.mutex, 0.1)
+            end
+          end
+        end
+
+        def apply_tool_decision(decision, display_name)
+          case decision
+          when :cancelled
+            @state.clear_tool_confirmation!
+            raise Tools::AgentCancelledError, "Operation cancelled by user"
+          when :approved
+            @state.resolve_tool_confirmation!(:approved)
+          when :rejected
+            @state.resolve_tool_confirmation!(:rejected)
+            raise Tools::ToolRejectedError, "User rejected #{display_name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/codex_bridge/tool_handling.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "tool_approval"
+
+module RubyCoded
+  module Chat
+    class CodexBridge
+      # Handles tool call execution, confirmation, and the multi-turn loop
+      # for agentic mode over the Codex Responses API.
+      module ToolHandling
+        include ToolApproval
+
+        private
+
+        def process_pending_tool_calls(pending_tool_calls, _original_input)
+          pending_tool_calls.each do |tool_call|
+            break if @cancel_requested
+
+            execute_tool_call(tool_call)
+          end
+
+          return if @cancel_requested
+
+          @state.add_message(:assistant, "")
+          continue_after_tools
+        end
+
+        def execute_tool_call(tool_call)
+          name = tool_call[:name]
+          args = parse_tool_arguments(tool_call[:arguments])
+          display_name = short_tool_name(name)
+          risk = @tool_registry.risk_level_for(name)
+
+          increment_call_counts(risk)
+          check_tool_limits!
+          warn_approaching_limit
+
+          request_approval(tool_call, display_name, args, risk)
+          result = run_tool(name, args)
+          record_tool_result(tool_call, result)
+        end
+
+        def parse_tool_arguments(args_str)
+          return args_str if args_str.is_a?(Hash)
+
+          JSON.parse(args_str)
+        rescue JSON::ParserError
+          {}
+        end
+
+        def run_tool(name, args)
+          tool_instances = @agentic_mode ? @tool_registry.build_tools : @tool_registry.build_readonly_tools
+          tool = tool_instances.find { |t| tool_name_match?(t, name) }
+
+          return { error: "Unknown tool: #{name}" } unless tool
+
+          symbolized = args.transform_keys(&:to_sym)
+          tool.execute(**symbolized)
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def tool_name_match?(tool, name)
+          tool.name == name || tool.name.split("--").last == name.split("--").last
+        end
+
+        def record_tool_result(tool_call, result)
+          @state.add_message(:tool_result, truncate_result(result))
+          record_tool_call_history(tool_call, result)
+        end
+
+        def truncate_result(result)
+          text = result.to_s
+          return text if text.length <= MAX_TOOL_RESULT_CHARS
+
+          "#{text[0, MAX_TOOL_RESULT_CHARS]}\n... (truncated, #{text.length} total characters)"
+        end
+
+        def record_tool_call_history(tool_call, result)
+          @conversation_history << {
+            type: "function_call", call_id: tool_call[:call_id],
+            name: tool_call[:name], arguments: tool_call[:arguments]
+          }
+          @conversation_history << {
+            type: "function_call_output", call_id: tool_call[:call_id], output: result.to_s
+          }
+        end
+
+        def continue_after_tools
+          perform_codex_request(nil)
+        end
+
+        def increment_call_counts(risk)
+          @tool_call_count += 1
+          @write_tool_call_count += 1 unless risk == Tools::BaseTool::SAFE_RISK
+        end
+
+        def check_tool_limits!
+          if @write_tool_call_count >= MAX_WRITE_TOOL_ROUNDS
+            @write_tool_call_count = 0
+            @state.add_message(:system,
+                               "Write tool call budget (#{MAX_WRITE_TOOL_ROUNDS}) reached — auto-resetting counter.")
+          end
+
+          return unless @tool_call_count > MAX_TOTAL_TOOL_ROUNDS
+
+          raise Tools::AgentIterationLimitError,
+                "Reached maximum of #{MAX_TOTAL_TOOL_ROUNDS} total tool calls. " \
+                "Send a new message to continue, or use /agent on to reset counters."
+        end
+
+        def warn_approaching_limit
+          threshold = (MAX_TOTAL_TOOL_ROUNDS * TOOL_ROUNDS_WARNING_THRESHOLD).to_i
+          return unless @tool_call_count == threshold
+
+          remaining = MAX_TOTAL_TOOL_ROUNDS - threshold
+          @state.add_message(:system,
+                             "Approaching total tool call limit: #{remaining} calls remaining. " \
+                             "Prioritize completing the most important work.")
+        end
+
+        def short_tool_name(name)
+          name.split("--").last
+        end
+      end
+    end
+  end
+end

data/lib/ruby_coded/chat/codex_bridge.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+require "time"
+
+require_relative "../tools/registry"
+require_relative "../tools/system_prompt"
+require_relative "../tools/plan_system_prompt"
+require_relative "../tools/agent_cancelled_error"
+require_relative "../tools/agent_iteration_limit_error"
+require_relative "../auth/jwt_decoder"
+require_relative "codex_bridge/request_builder"
+require_relative "codex_bridge/sse_parser"
+require_relative "codex_bridge/tool_handling"
+require_relative "codex_bridge/token_manager"
+require_relative "codex_bridge/error_handling"
+
+module RubyCoded
+  module Chat
+    # Raised when the Codex HTTP API returns a non-2xx response.
+    class CodexAPIError < StandardError
+      attr_reader :status
+
+      def initialize(status, detail)
+        @status = status
+        super("HTTP #{status}: #{detail}")
+      end
+    end
+
+    # HTTP client for the ChatGPT Codex backend (Responses API).
+    # Implements the same public interface as LLMBridge so App can
+    # swap between them based on the active auth_method.
+    class CodexBridge
+      include RequestBuilder
+      include SSEParser
+      include ToolHandling
+      include TokenManager
+      include ErrorHandling
+
+      CODEX_BASE_URL = "https://chatgpt.com"
+      CODEX_RESPONSES_PATH = "/backend-api/codex/responses"
+      DEFAULT_MODEL = "gpt-5.4"
+
+      MAX_RATE_LIMIT_RETRIES = 2
+      RATE_LIMIT_BASE_DELAY = 2
+      MAX_WRITE_TOOL_ROUNDS = 50
+      MAX_TOTAL_TOOL_ROUNDS = 200
+      TOOL_ROUNDS_WARNING_THRESHOLD = 0.8
+      MAX_TOOL_RESULT_CHARS = 10_000
+
+      attr_reader :agentic_mode, :plan_mode, :project_root
+
+      def initialize(state, credentials_store:, auth_manager:, project_root: Dir.pwd)
+        @state = state
+        @credentials_store = credentials_store
+        @auth_manager = auth_manager
+        @project_root = project_root
+        @cancel_requested = @agentic_mode = @plan_mode = false
+        @model = state.model
+        @conversation_history = []
+        @tool_registry = Tools::Registry.new(project_root: @project_root)
+        reset_call_counts
+        @conn = build_connection
+      end
+
+      def send_async(input)
+        prepare_send(input)
+        @conversation_history << { role: "user", content: input }
+        Thread.new do
+          attempt_with_retries(input)
+        ensure
+          @state.streaming = false
+        end
+      end
+
+      def cancel!
+        @cancel_requested = true
+        @state.mutex.synchronize { @state.tool_cv.signal }
+      end
+
+      def reset_chat!(model_name)
+        @model = model_name
+        @conversation_history = []
+      end
+
+      def toggle_agentic_mode!(enabled)
+        @agentic_mode = enabled
+        @state.agentic_mode = enabled
+        if enabled && @plan_mode
+          @plan_mode = false
+          @state.deactivate_plan_mode!
+        end
+        @state.disable_auto_approve! unless enabled
+      end
+
+      def toggle_plan_mode!(enabled)
+        @plan_mode = enabled
+        return unless enabled && @agentic_mode
+
+        @agentic_mode = false
+        @state.agentic_mode = false
+        @state.disable_auto_approve!
+      end
+
+      def approve_tool!
+        @state.tool_confirmation_response = :approved
+      end
+
+      def approve_all_tools!
+        @state.enable_auto_approve!
+        @state.tool_confirmation_response = :approved
+      end
+
+      def reject_tool!
+        @state.tool_confirmation_response = :rejected
+      end
+
+      def reset_agent_session!
+        @tool_call_count = 0
+        @write_tool_call_count = 0
+        @conversation_history = []
+      end
+    end
+  end
+end