schwab_mcp 0.1.0 → 0.2.0

data/lib/schwab_mcp/tools/place_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
@@ -20,7 +19,7 @@ module SchwabMCP
           },
           strategy_type: {
             type: "string",
-            enum: ["ironcondor", "callspread", "putspread"],
+            enum: %w[single ironcondor vertical],
             description: "Type of options strategy to place"
           },
           price: {
@@ -34,10 +33,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)"
@@ -56,14 +61,18 @@ module SchwabMCP
           },
           short_leg_symbol: {
             type: "string",
-            description: "Option symbol for the short leg (required for call/put spreads)"
+            description: "Option symbol for the short leg (required for vertical spreads)"
           },
           long_leg_symbol: {
             type: "string",
-            description: "Option symbol for the long leg (required for call/put spreads)"
-          }
+            description: "Option symbol for the long leg (required for vertical spreads)"
+          },
+          symbol: {
+            type: "string",
+            description: "Single option symbol to place an order for (required for single options)"
+          },
         },
-        required: ["account_name", "strategy_type", "price"]
+        required: %w[account_name strategy_type price]
       )
 
       annotations(
@@ -76,42 +85,31 @@ module SchwabMCP
       def self.call(server_context:, **params)
         log_info("Placing #{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],
@@ -119,7 +117,9 @@ 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
+            symbol: params[:symbol]
           )
 
           log_debug("Making place order API request")
@@ -129,77 +129,67 @@ module SchwabMCP
             log_info("Successfully placed #{params[:strategy_type]} order (HTTP #{response.status})")
             formatted_response = format_place_order_response(response, params)
             MCP::Tool::Response.new([{
-              type: "text",
-              text: formatted_response
-            }])
+                                      type: "text",
+                                      text: formatted_response
+                                    }])
           elsif response
             log_error("Order placement failed with HTTP status #{response.status}")
             error_details = extract_error_details(response)
             MCP::Tool::Response.new([{
-              type: "text",
-              text: "**Error**: Order placement failed (HTTP #{response.status})\n\n#{error_details}"
-            }])
+                                      type: "text",
+                                      text: "**Error**: Order placement failed (HTTP #{response.status})\n\n#{error_details}"
+                                    }])
           else
             log_warn("Empty response from Schwab API for order placement")
             MCP::Tool::Response.new([{
-              type: "text",
-              text: "**No Data**: Empty response from Schwab API for order placement"
-            }])
+                                      type: "text",
+                                      text: "**No Data**: Empty response from Schwab API for order placement"
+                                    }])
           end
-
-        rescue => e
+        rescue StandardError => e
           log_error("Error placing #{params[:strategy_type]} order: #{e.message}")
           log_debug("Backtrace: #{e.backtrace.first(5).join('\n')}")
           MCP::Tool::Response.new([{
-            type: "text",
-            text: "**Error** placing #{params[:strategy_type]} order: #{e.message}\n\n#{e.backtrace.first(3).join('\n')}"
-          }])
+                                    type: "text",
+                                    text: "**Error** placing #{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') }
+          available_accounts = ENV.keys.select { |key| key.end_with?("_ACCOUNT") }
           log_error("Account name '#{account_name}' not found in environment variables")
           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 environment variables.\n\nAvailable accounts: #{available_accounts.join(", ")}\n\nTo configure: Set ENV['#{account_name}'] to your account ID."
+                                         }])
         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
+        account_numbers = client.get_account_numbers
 
-        unless account_numbers_response&.body
+        unless account_numbers
           log_error("Failed to retrieve account numbers")
           return MCP::Tool::Response.new([{
-            type: "text",
-            text: "**Error**: Failed to retrieve account numbers from Schwab API"
-          }])
+                                           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)")
+        log_debug("Account mappings retrieved (#{account_numbers.size} accounts found)")
 
-        account_hash = nil
-        account_mappings.each do |mapping|
-          if mapping[:accountNumber] == account_id
-            account_hash = mapping[:hashValue]
-            break
-          end
-        end
+        account_hash = account_numbers.find_hash_value(account_id)
 
         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."
-          }])
+                                           type: "text",
+                                           text: "**Error**: Account ID not found in available accounts. #{account_numbers.size} accounts available."
+                                         }])
         end
 
         log_debug("Found account hash for account name: #{account_name}")
@@ -208,17 +198,17 @@ module SchwabMCP
 
       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]
+        when "ironcondor"
+          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 "callspread", "putspread"
+          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
         else
           raise ArgumentError, "Unsupported strategy type: #{params[:strategy_type]}"
@@ -226,60 +216,58 @@ module SchwabMCP
       end
 
       def self.format_place_order_response(response, params)
-        begin
-          strategy_summary = case params[:strategy_type]
-          when 'ironcondor'
-            "**Iron Condor Order Placed**\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 Placed**\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 = "**Order Details:**\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"
-
-          order_id = extract_order_id_from_response(response)
-          order_id_info = order_id ? "**Order ID**: #{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 submitted successfully (HTTP #{response.status})"
-          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}"
-        end
+        strategy_summary = case params[:strategy_type]
+                           when "ironcondor"
+                             "**Iron Condor Order Placed**\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 Placed**\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 = "**Order Details:**\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"
+
+        order_id = extract_order_id_from_response(response)
+        order_id_info = order_id ? "**Order ID**: #{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 submitted successfully (HTTP #{response.status})"
+                        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 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
 
         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
@@ -296,7 +284,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

data/lib/schwab_mcp/tools/preview_order_tool.rb

@@ -2,8 +2,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
@@ -20,7 +20,7 @@ module SchwabMCP
           },
           strategy_type: {
             type: "string",
-            enum: ["ironcondor", "callspread", "putspread"],
+            enum: ["ironcondor", "vertical", "single"],
             description: "Type of options strategy to preview"
           },
           price: {
@@ -38,6 +38,12 @@ module SchwabMCP
             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"
+          },
           # Iron Condor specific fields
           put_short_symbol: {
             type: "string",
@@ -63,6 +69,11 @@ module SchwabMCP
           long_leg_symbol: {
             type: "string",
             description: "Option symbol for the long leg (required for call/put spreads)"
+          },
+          # Single option specific field
+          symbol: {
+            type: "string",
+            description: "Single option symbol to place an order for (required for single options)"
           }
         },
         required: ["account_name", "strategy_type", "price"]
@@ -80,40 +91,30 @@ module SchwabMCP
 
         unless params[:account_name].end_with?('_ACCOUNT')
           log_error("Invalid account name format: #{params[:account_name]}")
+          error_msg = "**Error**: Account name must end with '_ACCOUNT'. Example: 'TRADING_BROKERAGE_ACCOUNT'"
           return MCP::Tool::Response.new([{
             type: "text",
-            text: "**Error**: Account name must end with '_ACCOUNT'. Example: 'TRADING_BROKERAGE_ACCOUNT'"
+            text: Redactor.redact_formatted_text(error_msg)
           }])
         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],
@@ -121,33 +122,36 @@ 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 preview order API request")
-          response = client.preview_order(account_hash, order_builder)
+          response = client.preview_order(account_hash, order_builder, return_data_objects: true)
 
-          if response&.body
+          if response
             log_info("Successfully previewed #{params[:strategy_type]} order")
-            formatted_response = format_preview_response(response.body, params)
+            formatted_response = format_preview_response(response, params)
             MCP::Tool::Response.new([{
               type: "text",
               text: formatted_response
             }])
           else
             log_warn("Empty response from Schwab API for order preview")
+            error_msg = "**No Data**: Empty response from Schwab API for order preview"
             MCP::Tool::Response.new([{
               type: "text",
-              text: "**No Data**: Empty response from Schwab API for order preview"
+              text: Redactor.redact_formatted_text(error_msg)
             }])
           end
 
         rescue => e
           log_error("Error previewing #{params[:strategy_type]} order: #{e.message}")
-          log_debug("Backtrace: #{e.backtrace.first(5).join('\n')}")
+          error_msg = "**Error** previewing #{params[:strategy_type]} order: #{e.message}\n\n#{e.backtrace.first(3).join('\\n')}"
           MCP::Tool::Response.new([{
             type: "text",
-            text: "**Error** previewing #{params[:strategy_type]} order: #{e.message}\n\n#{e.backtrace.first(3).join('\n')}"
+            text: Redactor.redact_formatted_text(error_msg)
           }])
         end
       end
@@ -159,46 +163,38 @@ module SchwabMCP
         unless account_id
           available_accounts = ENV.keys.select { |key| key.end_with?('_ACCOUNT') }
           log_error("Account name '#{account_name}' not found in environment variables")
+          error_msg = "**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."
           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."
+            text: Redactor.redact_formatted_text(error_msg)
           }])
         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")
+        account_numbers = client.get_account_numbers(return_data_objects: true)
+        unless account_numbers && !account_numbers.empty?
+          log_error("Failed to retrieve account numbers or no accounts returned")
+          error_msg = "**Error**: Failed to retrieve account numbers from Schwab API or no accounts returned"
           return MCP::Tool::Response.new([{
             type: "text",
-            text: "**Error**: Failed to retrieve account numbers from Schwab API"
+            text: Redactor.redact_formatted_text(error_msg)
           }])
         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
+        mapping = account_numbers.accounts.find { |acct| acct.account_number == account_id }
+        unless mapping
           log_error("Account ID not found in available accounts")
+          error_msg = "**Error**: Account ID not found in available accounts. #{account_numbers.size} accounts available."
           return MCP::Tool::Response.new([{
             type: "text",
-            text: "**Error**: Account ID not found in available accounts. #{account_mappings.length} accounts available."
+            text: Redactor.redact_formatted_text(error_msg)
           }])
         end
 
         log_debug("Found account hash for account name: #{account_name}")
-        [account_id, account_hash]
+        [account_id, mapping.hash_value]
       end
 
       def self.validate_strategy_params(params)
@@ -209,12 +205,18 @@ module SchwabMCP
           unless missing_fields.empty?
             raise ArgumentError, "Iron condor strategy requires: #{missing_fields.join(', ')}"
           end
-        when 'callspread', 'putspread'
+        when 'vertical'
           required_fields = [: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(', ')}"
           end
+        when 'single'
+          required_fields = [: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]}"
         end
@@ -232,10 +234,13 @@ module SchwabMCP
             "- 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} Preview**\n" \
+          when 'vertical'
+            "**Vertical Preview**\n" \
             "- Short Leg: #{params[:short_leg_symbol]}\n" \
             "- Long Leg: #{params[:long_leg_symbol]}\n"
+          when 'single'
+            "**Single Option Preview**\n" \
+            "- Symbol: #{params[:symbol]}\n"
           end
 
           friendly_name = params[:account_name].gsub('_ACCOUNT', '').split('_').map(&:capitalize).join(' ')
@@ -254,6 +259,53 @@ module SchwabMCP
           "**Order Preview Response:**\n\n```\n#{JSON.pretty_generate(redacted_data)}\n```"
         end
       end
+      def self.format_preview_response(order_preview, params)
+        # order_preview is a SchwabRb::DataObjects::OrderPreview
+        begin
+          strategy_summary = case params[:strategy_type]
+          when 'ironcondor'
+            "**Iron Condor Preview**\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 Preview**\n" \
+            "- Short Leg: #{params[:short_leg_symbol]}\n" \
+            "- Long Leg: #{params[:long_leg_symbol]}\n"
+          when 'single'
+            "**Single Option Preview**\n" \
+            "- Symbol: #{params[:symbol]}\n"
+          end
+
+          friendly_name = params[:account_name].gsub('_ACCOUNT', '').split('_').map(&:capitalize).join(' ')
+
+          order_details = "**Order Details:**\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"
+
+          # Use OrderPreview data object for summary
+          op = order_preview
+          summary = "**Preview Result:**\n" \
+                    "- Status: #{op.status || 'N/A'}\n" \
+                    "- Price: $#{op.price || 'N/A'}\n" \
+                    "- Quantity: #{op.quantity || 'N/A'}\n" \
+                    "- Commission: $#{op.commission}\n" \
+                    "- Fees: $#{op.fees}\n" \
+                    "- Accepted?: #{op.accepted? ? 'Yes' : 'No'}\n"
+
+          # Redact and pretty print the full data object as JSON
+          redacted_data = Redactor.redact(op.to_h)
+          full_response = "**Schwab API Preview Response:**\n\n```json\n#{JSON.pretty_generate(redacted_data)}\n```"
+
+          "#{strategy_summary}\n#{order_details}#{summary}\n#{full_response}"
+        rescue => e
+          "**Order Preview Response:**\n\nError formatting preview: #{e.message}"
+        end
+      end
     end
   end
 end