schwab_mcp 0.1.0 → 0.3.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 VERTICAL IRON_CONDOR],
             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,28 @@ 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,106 +114,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
+            symbol: params[:symbol]
           )
 
           log_debug("Making place order API request")
-          response = client.place_order(account_hash, order_builder)
+          response = client.place_order(account_name: params[:account_name], order: order_builder)
 
           if response && (200..299).include?(response.status)
             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') }
-          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."
-          }])
-        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")
+        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 ID not found in available accounts. #{account_mappings.length} accounts available."
-          }])
+                                           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 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]}"
@@ -226,60 +194,62 @@ 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}"
+        strategy = params[:strategy_type].to_s.upcase
+        strategy_summary = case strategy
+        when 'IRON_CONDOR'
+          "**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 'VERTICAL'
+          "**Vertical Spread Order Placed**\n" \
+          "- Short Leg: #{params[:short_leg_symbol]}\n" \
+          "- Long Leg: #{params[:long_leg_symbol]}\n"
+        when 'SINGLE'
+          "**Single Option Order Placed**\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"
+
+        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 +266,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: %w[SINGLE VERTICAL IRON_CONDOR],
             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,27 @@ 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 +119,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_name: params[:account_name], order: 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
@@ -155,87 +156,64 @@ module SchwabMCP
       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")
-          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."
-          }])
-        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")
+        available_accounts = client.available_account_names
+        unless available_accounts.include?(account_name)
+          log_error("Account name '#{account_name}' not found in configured accounts")
+          error_msg = "**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."
           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]
+        log_debug("Using account name: #{account_name}")
+        account_name
       end
 
       def self.validate_strategy_params(params)
-        case params[:strategy_type]
-        when 'ironcondor'
+        strategy = params[:strategy_type].to_s.upcase
+        case strategy
+        when 'IRON_CONDOR'
           required_fields = [: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(', ')}"
           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
       end
 
-      def self.format_preview_response(response_body, params)
-        parsed = JSON.parse(response_body)
-        redacted_data = Redactor.redact(parsed)
-
+      def self.format_preview_response(order_preview, params)
+        # order_preview is a SchwabRb::DataObjects::OrderPreview
         begin
-          strategy_summary = case params[:strategy_type]
-          when 'ironcondor'
+          strategy = params[:strategy_type].to_s.upcase
+          strategy_summary = case strategy
+          when 'IRON_CONDOR'
             "**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 'callspread', 'putspread'
-            "**#{params[:strategy_type].capitalize} Preview**\n" \
+          when 'VERTICAL'
+            "**Vertical Spread 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(' ')
@@ -247,11 +225,23 @@ module SchwabMCP
                          "- 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}#{full_response}"
-        rescue JSON::ParserError
-          "**Order Preview Response:**\n\n```\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