schwab_mcp 0.1.0 → 0.3.0

data/lib/schwab_mcp/tools/quote_tool.rb

@@ -1,7 +1,10 @@
+
+# frozen_string_literal: true
+
 require "mcp"
 require "schwab_rb"
-require "json"
 require_relative "../loggable"
+require_relative "../schwab_client_factory"
 
 module SchwabMCP
   module Tools
@@ -13,8 +16,8 @@ module SchwabMCP
         properties: {
           symbol: {
             type: "string",
-            description: "Instrument symbol (e.g., 'AAPL', 'TSLA')",
-            pattern: "^[A-Za-z]{1,5}$"
+            description: "Instrument symbol (e.g., 'AAPL', 'TSLA', '$SPX')",
+            pattern: '^[\$\^]?[A-Za-z0-9]{1,5}$'
           }
         },
         required: ["symbol"]
@@ -31,38 +34,27 @@ module SchwabMCP
         log_info("Getting quote for symbol: #{symbol}")
 
         begin
-          client = SchwabRb::Auth.init_client_easy(
-            ENV['SCHWAB_API_KEY'],
-            ENV['SCHWAB_APP_SECRET'],
-            ENV['SCHWAB_CALLBACK_URI'],
-            ENV['TOKEN_PATH']
-          )
-
-          unless client
-            log_error("Failed to initialize Schwab client")
-            return MCP::Tool::Response.new([{
-              type: "text",
-              text: "**Error**: Failed to initialize Schwab client. Check your credentials."
-            }])
-          end
+          client = SchwabClientFactory.create_client
+          return SchwabClientFactory.client_error_response unless client
 
           log_debug("Making API request for symbol: #{symbol}")
-          response = client.get_quote(symbol.upcase)
+          quote_obj = client.get_quote(symbol.upcase)
 
-          if response&.body
-            log_info("Successfully retrieved quote for #{symbol}")
-            MCP::Tool::Response.new([{
-              type: "text",
-              text: "**Quote for #{symbol.upcase}:**\n\n```json\n#{response.body}\n```"
-            }])
-          else
-            log_warn("Empty response from Schwab API for symbol: #{symbol}")
-            MCP::Tool::Response.new([{
+          unless quote_obj
+            log_warn("No quote data object returned for symbol: #{symbol}")
+            return MCP::Tool::Response.new([{
               type: "text",
-              text: "**No Data**: Empty response from Schwab API for symbol: #{symbol}"
+              text: "**No Data**: No quote data returned for symbol: #{symbol}"
             }])
           end
 
+          formatted = format_quote_object(quote_obj)
+          log_info("Successfully retrieved quote for #{symbol}")
+          MCP::Tool::Response.new([{
+            type: "text",
+            text: "**Quote for #{symbol.upcase}:**\n\n#{formatted}"
+          }])
+
         rescue => e
           log_error("Error retrieving quote for #{symbol}: #{e.message}")
           log_debug("Backtrace: #{e.backtrace.first(3).join('\n')}")
@@ -72,6 +64,19 @@ module SchwabMCP
           }])
         end
       end
+
+      def self.format_quote_object(obj)
+        case obj
+        when SchwabRb::DataObjects::OptionQuote
+          "Option: #{obj.symbol}\nLast: #{obj.last_price}  Bid: #{obj.bid_price}  Ask: #{obj.ask_price}  Mark: #{obj.mark}  Delta: #{obj.delta}  Gamma: #{obj.gamma}  Vol: #{obj.volatility}  OI: #{obj.open_interest}  Exp: #{obj.expiration_month}/#{obj.expiration_day}/#{obj.expiration_year}  Strike: #{obj.strike_price}"
+        when SchwabRb::DataObjects::EquityQuote
+          "Equity: #{obj.symbol}\nLast: #{obj.last_price}  Bid: #{obj.bid_price}  Ask: #{obj.ask_price}  Mark: #{obj.mark}  Net Chg: #{obj.net_change}  %Chg: #{obj.net_percent_change}  Vol: #{obj.total_volume}"
+        when SchwabRb::DataObjects::IndexQuote
+          "Index: #{obj.symbol}\nLast: #{obj.last_price}  Bid: N/A  Ask: N/A  Mark: #{obj.mark}  Net Chg: #{obj.net_change}  %Chg: #{obj.net_percent_change}  Vol: #{obj.total_volume}"
+        else
+          obj.respond_to?(:to_h) ? obj.to_h.inspect : obj.inspect
+        end
+      end
     end
   end
 end

data/lib/schwab_mcp/tools/quotes_tool.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require "mcp"
 require "schwab_rb"
-require "json"
 require_relative "../loggable"
+require_relative "../schwab_client_factory"
 
 module SchwabMCP
   module Tools
@@ -44,67 +46,117 @@ module SchwabMCP
         idempotent_hint: true
       )
 
-      def self.call(symbols:, fields: ["quote"], indicative: false, server_context:)
+      def self.call(symbols:, server_context:, fields: ["quote"], indicative: false)
         symbols = [symbols] if symbols.is_a?(String)
 
-        log_info("Getting quotes for #{symbols.length} symbols: #{symbols.join(', ')}")
+        log_info("Getting quotes for #{symbols.length} symbols: #{symbols.join(", ")}")
 
         begin
-          client = SchwabRb::Auth.init_client_easy(
-            ENV['SCHWAB_API_KEY'],
-            ENV['SCHWAB_APP_SECRET'],
-            ENV['SCHWAB_CALLBACK_URI'],
-            ENV['TOKEN_PATH']
-          )
+          client = SchwabClientFactory.create_client
+          return SchwabClientFactory.client_error_response unless client
 
-          unless client
-            log_error("Failed to initialize Schwab client")
-            return MCP::Tool::Response.new([{
-              type: "text",
-              text: "**Error**: Failed to initialize Schwab client. Check your credentials."
-            }])
-          end
-
-          log_debug("Making API request for symbols: #{symbols.join(', ')}")
-          log_debug("Fields: #{fields || 'all'}")
-          log_debug("Indicative: #{indicative || 'not specified'}")
+          log_debug("Making API request for symbols: #{symbols.join(", ")}")
+          log_debug("Fields: #{fields || "all"}")
+          log_debug("Indicative: #{indicative || "not specified"}")
 
           normalized_symbols = symbols.map(&:upcase)
 
-          response = client.get_quotes(
+          quotes_data = client.get_quotes(
             normalized_symbols,
             fields: fields,
-            indicative: indicative
+            indicative: indicative,
+            return_data_objects: true
           )
 
-          if response&.body
-            log_info("Successfully retrieved quotes for #{symbols.length} symbols")
-
-            symbol_list = normalized_symbols.join(', ')
-            field_info = fields ? " (fields: #{fields.join(', ')})" : " (all fields)"
-            indicative_info = indicative.nil? ? "" : " (indicative: #{indicative})"
-
-            MCP::Tool::Response.new([{
-              type: "text",
-              text: "**Quotes for #{symbol_list}:**#{field_info}#{indicative_info}\n\n```json\n#{response.body}\n```"
-            }])
-          else
-            log_warn("Empty response from Schwab API for symbols: #{symbols.join(', ')}")
-            MCP::Tool::Response.new([{
-              type: "text",
-              text: "**No Data**: Empty response from Schwab API for symbols: #{symbols.join(', ')}"
-            }])
+          unless quotes_data
+            log_warn("No quote data objects returned for symbols: #{symbols.join(", ")}")
+            return MCP::Tool::Response.new([{
+                                             type: "text",
+                                             text: "**No Data**: No quote data returned for symbols: " \
+                                                   "#{symbols.join(", ")}"
+                                           }])
           end
 
-        rescue => e
-          log_error("Error retrieving quotes for #{symbols.join(', ')}: #{e.message}")
-          log_debug("Backtrace: #{e.backtrace.first(3).join('\n')}")
+          # Format quotes output
+          formatted_quotes = format_quotes_data(quotes_data, normalized_symbols)
+          log_info("Successfully retrieved quotes for #{symbols.length} symbols")
+
+          symbol_list = normalized_symbols.join(", ")
+          field_info = fields ? " (fields: #{fields.join(", ")})" : " (all fields)"
+          indicative_info = indicative.nil? ? "" : " (indicative: #{indicative})"
+
+          MCP::Tool::Response.new([{
+                                    type: "text",
+                                    text: "**Quotes for #{symbol_list}:**#{field_info}#{indicative_info}\n\n" \
+                                          "#{formatted_quotes}"
+                                  }])
+        rescue StandardError => e
+          log_error("Error retrieving quotes for #{symbols.join(", ")}: #{e.message}")
+          log_debug("Backtrace: #{e.backtrace.first(3).join("\n")}")
           MCP::Tool::Response.new([{
-            type: "text",
-            text: "**Error** retrieving quotes for #{symbols.join(', ')}: #{e.message}\n\n#{e.backtrace.first(3).join('\n')}"
-          }])
+                                    type: "text",
+                                    text: "**Error** retrieving quotes for #{symbols.join(", ")}: #{e.message}\n\n" \
+                                          "#{e.backtrace.first(3).join("\n")}"
+                                  }])
+        end
+      end
+
+      # Format the quotes data for display
+      def self.format_quotes_data(quotes_data, symbols)
+        return "No quotes available" unless quotes_data
+
+        case quotes_data
+        when Hash
+          format_hash_quotes(quotes_data, symbols)
+        when Array
+          quotes_data.map { |quote_obj| format_single_quote(quote_obj) }.join("\n\n")
+        else
+          format_single_quote(quotes_data)
         end
       end
+
+      # Format hash of quotes (symbol => quote_object)
+      def self.format_hash_quotes(quotes_data, symbols)
+        formatted_lines = symbols.map do |symbol|
+          quote_obj = quotes_data[symbol] || quotes_data[symbol.to_sym]
+          quote_obj ? format_single_quote(quote_obj) : "#{symbol}: No data available"
+        end
+        formatted_lines.join("\n\n")
+      end
+
+      # Format a single quote object for display (reused from quote_tool.rb)
+      def self.format_single_quote(obj)
+        case obj
+        when SchwabRb::DataObjects::OptionQuote
+          format_option_quote(obj)
+        when SchwabRb::DataObjects::EquityQuote
+          format_equity_quote(obj)
+        when SchwabRb::DataObjects::IndexQuote
+          format_index_quote(obj)
+        else
+          obj.respond_to?(:to_h) ? obj.to_h.inspect : obj.inspect
+        end
+      end
+
+      # Format option quote
+      def self.format_option_quote(obj)
+        "Option: #{obj.symbol}\nLast: #{obj.last_price}  Bid: #{obj.bid_price}  Ask: #{obj.ask_price}  " \
+        "Mark: #{obj.mark}  Delta: #{obj.delta}  Gamma: #{obj.gamma}  Vol: #{obj.volatility}  " \
+        "OI: #{obj.open_interest}  Exp: #{obj.expiration_month}/#{obj.expiration_day}/#{obj.expiration_year}  " \
+        "Strike: #{obj.strike_price}"
+      end
+
+      # Format equity quote
+      def self.format_equity_quote(obj)
+        "Equity: #{obj.symbol}\nLast: #{obj.last_price}  Bid: #{obj.bid_price}  Ask: #{obj.ask_price}  " \
+        "Mark: #{obj.mark}  Net Chg: #{obj.net_change}  %Chg: #{obj.net_percent_change}  Vol: #{obj.total_volume}"
+      end
+
+      # Format index quote
+      def self.format_index_quote(obj)
+        "Index: #{obj.symbol}\nLast: #{obj.last_price}  Bid: N/A  Ask: N/A  Mark: #{obj.mark}  " \
+        "Net Chg: #{obj.net_change}  %Chg: #{obj.net_percent_change}  Vol: #{obj.total_volume}"
+      end
     end
   end
 end

data/lib/schwab_mcp/tools/replace_order_tool.rb

@@ -1,9 +1,8 @@
 require "mcp"
 require "schwab_rb"
-require "json"
 require_relative "../loggable"
-require_relative "../orders/order_factory"
 require_relative "../redactor"
+require_relative "../schwab_client_factory"
 
 module SchwabMCP
   module Tools
@@ -24,7 +23,7 @@ module SchwabMCP
           },
           strategy_type: {
             type: "string",
-            enum: ["ironcondor", "callspread", "putspread"],
+            enum: %w[SINGLE VERTICAL IRON_CONDOR],
             description: "Type of options strategy for the replacement order"
           },
           price: {
@@ -38,10 +37,16 @@ module SchwabMCP
           },
           order_instruction: {
             type: "string",
-            enum: ["open", "exit"],
+            enum: %w[open exit],
             description: "Whether to open a new position or exit an existing one (default: open)",
             default: "open"
           },
+          credit_debit: {
+            type: "string",
+            enum: %w[credit debit],
+            description: "Whether the order is a credit or debit (default: credit)",
+            default: "credit"
+          },
           put_short_symbol: {
             type: "string",
             description: "Option symbol for the short put leg (required for iron condor)"
@@ -65,9 +70,13 @@ module SchwabMCP
           long_leg_symbol: {
             type: "string",
             description: "Option symbol for the long leg (required for call/put spreads)"
+          },
+          symbol: {
+            type: "string",
+            description: "Single option symbol to place an order for (required for single options)"
           }
         },
-        required: ["account_name", "order_id", "strategy_type", "price"]
+        required: %w[account_name order_id strategy_type price]
       )
 
       annotations(
@@ -80,42 +89,28 @@ module SchwabMCP
       def self.call(server_context:, **params)
         log_info("Replacing order #{params[:order_id]} with #{params[:strategy_type]} order for account name: #{params[:account_name]}")
 
-        unless params[:account_name].end_with?('_ACCOUNT')
+        unless params[:account_name].end_with?("_ACCOUNT")
           log_error("Invalid account name format: #{params[:account_name]}")
           return MCP::Tool::Response.new([{
-            type: "text",
-            text: "**Error**: Account name must end with '_ACCOUNT'. Example: 'TRADING_BROKERAGE_ACCOUNT'"
-          }])
+                                           type: "text",
+                                           text: "**Error**: Account name must end with '_ACCOUNT'. Example: 'TRADING_BROKERAGE_ACCOUNT'"
+                                         }])
         end
 
         begin
           validate_strategy_params(params)
-          client = SchwabRb::Auth.init_client_easy(
-            ENV['SCHWAB_API_KEY'],
-            ENV['SCHWAB_APP_SECRET'],
-            ENV['SCHWAB_CALLBACK_URI'],
-            ENV['TOKEN_PATH']
-          )
-
-          unless client
-            log_error("Failed to initialize Schwab client")
-            return MCP::Tool::Response.new([{
-              type: "text",
-              text: "**Error**: Failed to initialize Schwab client. Check your credentials."
-            }])
-          end
+          client = SchwabClientFactory.create_client
+          return SchwabClientFactory.client_error_response unless client
 
           account_result = resolve_account_details(client, params[:account_name])
           return account_result if account_result.is_a?(MCP::Tool::Response)
 
-          account_id, account_hash = account_result
-
-          order_builder = SchwabMCP::Orders::OrderFactory.build(
+          order_builder = SchwabRb::Orders::OrderFactory.build(
             strategy_type: params[:strategy_type],
-            account_number: account_id,
             price: params[:price],
             quantity: params[:quantity] || 1,
             order_instruction: (params[:order_instruction] || "open").to_sym,
+            credit_debit: (params[:credit_debit] || "credit").to_sym,
             # Iron Condor params
             put_short_symbol: params[:put_short_symbol],
             put_long_symbol: params[:put_long_symbol],
@@ -123,106 +118,79 @@ module SchwabMCP
             call_long_symbol: params[:call_long_symbol],
             # Vertical spread params
             short_leg_symbol: params[:short_leg_symbol],
-            long_leg_symbol: params[:long_leg_symbol]
+            long_leg_symbol: params[:long_leg_symbol],
+            # Single option params
+            symbol: params[:symbol]
           )
 
           log_debug("Making replace order API request for order ID: #{params[:order_id]}")
-          response = client.replace_order(account_hash, params[:order_id], order_builder)
+          response = client.replace_order(account_name: params[:account_name], order_id: params[:order_id], order: order_builder)
 
           if response && (200..299).include?(response.status)
             log_info("Successfully replaced order #{params[:order_id]} with #{params[:strategy_type]} order (HTTP #{response.status})")
             formatted_response = format_replace_order_response(response, params)
             MCP::Tool::Response.new([{
-              type: "text",
-              text: formatted_response
-            }])
+                                      type: "text",
+                                      text: formatted_response
+                                    }])
           elsif response
             log_error("Order replacement failed with HTTP status #{response.status}")
             error_details = extract_error_details(response)
             MCP::Tool::Response.new([{
-              type: "text",
-              text: "**Error**: Order replacement failed (HTTP #{response.status})\n\n#{error_details}"
-            }])
+                                      type: "text",
+                                      text: "**Error**: Order replacement failed (HTTP #{response.status})\n\n#{error_details}"
+                                    }])
           else
             log_warn("Empty response from Schwab API for order replacement")
             MCP::Tool::Response.new([{
-              type: "text",
-              text: "**No Data**: Empty response from Schwab API for order replacement"
-            }])
+                                      type: "text",
+                                      text: "**No Data**: Empty response from Schwab API for order replacement"
+                                    }])
           end
-
-        rescue => e
+        rescue StandardError => e
           log_error("Error replacing order #{params[:order_id]} with #{params[:strategy_type]} order: #{e.message}")
           log_debug("Backtrace: #{e.backtrace.first(5).join('\n')}")
           MCP::Tool::Response.new([{
-            type: "text",
-            text: "**Error** replacing order #{params[:order_id]} with #{params[:strategy_type]} order: #{e.message}\n\n#{e.backtrace.first(3).join('\n')}"
-          }])
+                                    type: "text",
+                                    text: "**Error** replacing order #{params[:order_id]} with #{params[:strategy_type]} order: #{e.message}\n\n#{e.backtrace.first(3).join('\n')}"
+                                  }])
         end
       end
 
-      private
-
       def self.resolve_account_details(client, account_name)
-        account_id = ENV[account_name]
-        unless account_id
-          available_accounts = ENV.keys.select { |key| key.end_with?('_ACCOUNT') }
-          log_error("Account name '#{account_name}' not found in environment variables")
+        available_accounts = client.available_account_names
+        unless available_accounts.include?(account_name)
+          log_error("Account name '#{account_name}' not found in configured accounts")
           return MCP::Tool::Response.new([{
-            type: "text",
-            text: "**Error**: Account name '#{account_name}' not found in environment variables.\n\nAvailable accounts: #{available_accounts.join(', ')}\n\nTo configure: Set ENV['#{account_name}'] to your account ID."
-          }])
+                                           type: "text",
+                                           text: "**Error**: Account name '#{account_name}' not found in configured accounts.\n\nAvailable accounts: #{available_accounts.join(", ")}\n\nTo configure: Add the account to your schwab_rb configuration file."
+                                         }])
         end
 
-        log_debug("Found account ID: [REDACTED] for account name: #{account_name}")
-        log_debug("Fetching account numbers mapping")
-
-        account_numbers_response = client.get_account_numbers
-
-        unless account_numbers_response&.body
-          log_error("Failed to retrieve account numbers")
-          return MCP::Tool::Response.new([{
-            type: "text",
-            text: "**Error**: Failed to retrieve account numbers from Schwab API"
-          }])
-        end
-
-        account_mappings = JSON.parse(account_numbers_response.body, symbolize_names: true)
-        log_debug("Account mappings retrieved (#{account_mappings.length} accounts found)")
-
-        account_hash = nil
-        account_mappings.each do |mapping|
-          if mapping[:accountNumber] == account_id
-            account_hash = mapping[:hashValue]
-            break
-          end
-        end
-
-        unless account_hash
-          log_error("Account ID not found in available accounts")
-          return MCP::Tool::Response.new([{
-            type: "text",
-            text: "**Error**: Account ID not found in available accounts. #{account_mappings.length} accounts available."
-          }])
-        end
-
-        log_debug("Found account hash for account name: #{account_name}")
-        [account_id, account_hash]
+        log_debug("Using account name: #{account_name}")
+        account_name
       end
 
       def self.validate_strategy_params(params)
-        case params[:strategy_type]
-        when 'ironcondor'
-          required_fields = [:put_short_symbol, :put_long_symbol, :call_short_symbol, :call_long_symbol]
+        strategy = params[:strategy_type].to_s.upcase
+        case strategy
+        when 'IRON_CONDOR'
+          required_fields = %i[put_short_symbol put_long_symbol call_short_symbol call_long_symbol]
           missing_fields = required_fields.select { |field| params[field].nil? || params[field].empty? }
           unless missing_fields.empty?
-            raise ArgumentError, "Iron condor strategy requires: #{missing_fields.join(', ')}"
+            raise ArgumentError, "Iron condor strategy requires: #{missing_fields.join(", ")}"
           end
-        when 'callspread', 'putspread'
-          required_fields = [:short_leg_symbol, :long_leg_symbol]
+        when 'VERTICAL'
+          required_fields = %i[short_leg_symbol long_leg_symbol]
           missing_fields = required_fields.select { |field| params[field].nil? || params[field].empty? }
           unless missing_fields.empty?
-            raise ArgumentError, "#{params[:strategy_type]} strategy requires: #{missing_fields.join(', ')}"
+            raise ArgumentError, "#{params[:strategy_type]} strategy requires: #{missing_fields.join(", ")}"
+          end
+        when 'SINGLE'
+          required_fields = %i[symbol]
+          missing_fields = required_fields.select { |field| params[field].nil? || params[field].empty? }
+          unless missing_fields.empty?
+            raise ArgumentError, "#{params[:strategy_type]} strategy requires: #{missing_fields.join(", ")}"
           end
         else
           raise ArgumentError, "Unsupported strategy type: #{params[:strategy_type]}"
@@ -230,63 +198,65 @@ module SchwabMCP
       end
 
       def self.format_replace_order_response(response, params)
-        begin
-          strategy_summary = case params[:strategy_type]
-          when 'ironcondor'
-            "**Iron Condor Order Replaced**\n" \
-            "- Put Short: #{params[:put_short_symbol]}\n" \
-            "- Put Long: #{params[:put_long_symbol]}\n" \
-            "- Call Short: #{params[:call_short_symbol]}\n" \
-            "- Call Long: #{params[:call_long_symbol]}\n"
-          when 'callspread', 'putspread'
-            "**#{params[:strategy_type].capitalize} Order Replaced**\n" \
-            "- Short Leg: #{params[:short_leg_symbol]}\n" \
-            "- Long Leg: #{params[:long_leg_symbol]}\n"
-          end
-
-          friendly_name = params[:account_name].gsub('_ACCOUNT', '').split('_').map(&:capitalize).join(' ')
-
-          order_details = "**Replacement Order Details:**\n" \
-                         "- Original Order ID: #{params[:order_id]}\n" \
-                         "- Strategy: #{params[:strategy_type]}\n" \
-                         "- Action: #{params[:order_instruction] || 'open'}\n" \
-                         "- Quantity: #{params[:quantity] || 1}\n" \
-                         "- Price: $#{params[:price]}\n" \
-                         "- Account: #{friendly_name} (#{params[:account_name]})\n\n"
-
-          new_order_id = extract_order_id_from_response(response)
-          order_id_info = new_order_id ? "**New Order ID**: #{new_order_id}\n\n" : ""
-
-          response_info = if response.body && !response.body.empty?
-            begin
-              parsed = JSON.parse(response.body)
-              redacted_data = Redactor.redact(parsed)
-              "**Schwab API Response:**\n\n```json\n#{JSON.pretty_generate(redacted_data)}\n```"
-            rescue JSON::ParserError
-              "**Schwab API Response:**\n\n```\n#{response.body}\n```"
-            end
-          else
-            "**Status**: Order replaced successfully (HTTP #{response.status})\n\n" \
-            "The original order has been canceled and a new order has been created."
-          end
-
-          "#{strategy_summary}\n#{order_details}#{order_id_info}#{response_info}"
-        rescue => e
-          log_error("Error formatting response: #{e.message}")
-          "**Order Status**: #{response.status}\n\n**Raw Response**: #{response.body}"
+        strategy = params[:strategy_type].to_s.upcase
+        strategy_summary = case strategy
+        when 'IRON_CONDOR'
+          "**Iron Condor Order Replaced**\n" \
+          "- Put Short: #{params[:put_short_symbol]}\n" \
+          "- Put Long: #{params[:put_long_symbol]}\n" \
+          "- Call Short: #{params[:call_short_symbol]}\n" \
+          "- Call Long: #{params[:call_long_symbol]}\n"
+        when 'VERTICAL'
+          "**Vertical Spread Order Replaced**\n" \
+          "- Short Leg: #{params[:short_leg_symbol]}\n" \
+          "- Long Leg: #{params[:long_leg_symbol]}\n"
+        when 'SINGLE'
+          "**Single Option Order Replaced**\n" \
+          "- Symbol: #{params[:symbol]}\n"
         end
+
+        friendly_name = params[:account_name].gsub("_ACCOUNT", "").split("_").map(&:capitalize).join(" ")
+
+        order_details = "**Replacement Order Details:**\n" \
+                       "- Original Order ID: #{params[:order_id]}\n" \
+                       "- Strategy: #{params[:strategy_type]}\n" \
+                       "- Action: #{params[:order_instruction] || "open"}\n" \
+                       "- Quantity: #{params[:quantity] || 1}\n" \
+                       "- Price: $#{params[:price]}\n" \
+                       "- Account: #{friendly_name} (#{params[:account_name]})\n\n"
+
+        new_order_id = extract_order_id_from_response(response)
+        order_id_info = new_order_id ? "**New Order ID**: #{new_order_id}\n\n" : ""
+
+        response_info = if response.body && !response.body.empty?
+                          begin
+                            parsed = JSON.parse(response.body)
+                            redacted_data = Redactor.redact(parsed)
+                            "**Schwab API Response:**\n\n```json\n#{JSON.pretty_generate(redacted_data)}\n```"
+                          rescue JSON::ParserError
+                            "**Schwab API Response:**\n\n```\n#{response.body}\n```"
+                          end
+                        else
+                          "**Status**: Order replaced successfully (HTTP #{response.status})\n\n" \
+                          "The original order has been canceled and a new order has been created."
+                        end
+
+        "#{strategy_summary}\n#{order_details}#{order_id_info}#{response_info}"
+      rescue StandardError => e
+        log_error("Error formatting response: #{e.message}")
+        "**Order Status**: #{response.status}\n\n**Raw Response**: #{response.body}"
       end
 
       def self.extract_order_id_from_response(response)
         # Schwab API typically returns the new order ID in the Location header
         # Format: https://api.schwabapi.com/trader/v1/accounts/{accountHash}/orders/{orderId}
-        location = response.headers['Location'] || response.headers['location']
+        location = response.headers["Location"] || response.headers["location"]
         return nil unless location
 
         # Extract order ID from the URL path
         match = location.match(%r{/orders/(\d+)$})
         match ? match[1] : nil
-      rescue => e
+      rescue StandardError => e
         log_debug("Could not extract order ID from response: #{e.message}")
         nil
       end
@@ -303,7 +273,7 @@ module SchwabMCP
         else
           "No additional error details provided."
         end
-      rescue => e
+      rescue StandardError => e
         log_debug("Error extracting error details: #{e.message}")
         "Could not extract error details."
       end