schwab_mcp 0.1.0

data/lib/schwab_mcp/tools/replace_order_tool.rb

@@ -0,0 +1,312 @@
+require "mcp"
+require "schwab_rb"
+require "json"
+require_relative "../loggable"
+require_relative "../orders/order_factory"
+require_relative "../redactor"
+
+module SchwabMCP
+  module Tools
+    class ReplaceOrderTool < MCP::Tool
+      extend Loggable
+      description "Replace an existing options order with a new order (iron condor, call spread, put spread). The existing order will be canceled and a new order will be created."
+
+      input_schema(
+        properties: {
+          account_name: {
+            type: "string",
+            description: "Account name mapped to environment variable ending with '_ACCOUNT' (e.g., 'TRADING_BROKERAGE_ACCOUNT')",
+            pattern: "^[A-Z_]+_ACCOUNT$"
+          },
+          order_id: {
+            type: "string",
+            description: "The ID of the existing order to replace"
+          },
+          strategy_type: {
+            type: "string",
+            enum: ["ironcondor", "callspread", "putspread"],
+            description: "Type of options strategy for the replacement order"
+          },
+          price: {
+            type: "number",
+            description: "Net price for the replacement order (credit for selling strategies, debit for buying strategies)"
+          },
+          quantity: {
+            type: "integer",
+            description: "Number of contracts (default: 1)",
+            default: 1
+          },
+          order_instruction: {
+            type: "string",
+            enum: ["open", "exit"],
+            description: "Whether to open a new position or exit an existing one (default: open)",
+            default: "open"
+          },
+          put_short_symbol: {
+            type: "string",
+            description: "Option symbol for the short put leg (required for iron condor)"
+          },
+          put_long_symbol: {
+            type: "string",
+            description: "Option symbol for the long put leg (required for iron condor)"
+          },
+          call_short_symbol: {
+            type: "string",
+            description: "Option symbol for the short call leg (required for iron condor)"
+          },
+          call_long_symbol: {
+            type: "string",
+            description: "Option symbol for the long call leg (required for iron condor)"
+          },
+          short_leg_symbol: {
+            type: "string",
+            description: "Option symbol for the short leg (required for call/put spreads)"
+          },
+          long_leg_symbol: {
+            type: "string",
+            description: "Option symbol for the long leg (required for call/put spreads)"
+          }
+        },
+        required: ["account_name", "order_id", "strategy_type", "price"]
+      )
+
+      annotations(
+        title: "Replace Options Order",
+        read_only_hint: false,
+        destructive_hint: true,
+        idempotent_hint: false
+      )
+
+      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')
+          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'"
+          }])
+        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
+
+          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(
+            strategy_type: params[:strategy_type],
+            account_number: account_id,
+            price: params[:price],
+            quantity: params[:quantity] || 1,
+            order_instruction: (params[:order_instruction] || "open").to_sym,
+            # Iron Condor params
+            put_short_symbol: params[:put_short_symbol],
+            put_long_symbol: params[:put_long_symbol],
+            call_short_symbol: params[:call_short_symbol],
+            call_long_symbol: params[:call_long_symbol],
+            # Vertical spread params
+            short_leg_symbol: params[:short_leg_symbol],
+            long_leg_symbol: params[:long_leg_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)
+
+          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
+            }])
+          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}"
+            }])
+          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"
+            }])
+          end
+
+        rescue => 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')}"
+          }])
+        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")
+          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]
+      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]
+          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'
+          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
+        else
+          raise ArgumentError, "Unsupported strategy type: #{params[:strategy_type]}"
+        end
+      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}"
+        end
+      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']
+        return nil unless location
+
+        # Extract order ID from the URL path
+        match = location.match(%r{/orders/(\d+)$})
+        match ? match[1] : nil
+      rescue => e
+        log_debug("Could not extract order ID from response: #{e.message}")
+        nil
+      end
+
+      def self.extract_error_details(response)
+        if response.body && !response.body.empty?
+          begin
+            parsed = JSON.parse(response.body)
+            redacted_data = Redactor.redact(parsed)
+            "**Error Details:**\n\n```json\n#{JSON.pretty_generate(redacted_data)}\n```"
+          rescue JSON::ParserError
+            "**Error Details:**\n\n```\n#{response.body}\n```"
+          end
+        else
+          "No additional error details provided."
+        end
+      rescue => e
+        log_debug("Error extracting error details: #{e.message}")
+        "Could not extract error details."
+      end
+    end
+  end
+end

data/lib/schwab_mcp/tools/schwab_account_details_tool.rb

@@ -0,0 +1,208 @@
+require "mcp"
+require "schwab_rb"
+require "json"
+require_relative "../loggable"
+require_relative "../redactor"
+
+module SchwabMCP
+  module Tools
+    class SchwabAccountDetailsTool < MCP::Tool
+      extend Loggable
+      description "Get account information for a specific account using account name mapping"
+
+      input_schema(
+        properties: {
+          account_name: {
+            type: "string",
+            description: "Account name mapped to environment variable ending with '_ACCOUNT' (e.g., 'TRADING_BROKERAGE_ACCOUNT')",
+            pattern: "^[A-Z_]+_ACCOUNT$"
+          },
+          fields: {
+            type: "array",
+            description: "Optional account fields to retrieve (balances, positions, orders)",
+            items: {
+              type: "string"
+            }
+          }
+        },
+        required: ["account_name"]
+      )
+
+      annotations(
+        title: "Get Schwab Account Information",
+        read_only_hint: true,
+        destructive_hint: false,
+        idempotent_hint: true
+      )
+
+      def self.call(account_name:, fields: nil, server_context:)
+        log_info("Getting account information for account name: #{account_name}")
+
+        unless account_name.end_with?('_ACCOUNT')
+          log_error("Invalid account name format: #{account_name}")
+          return MCP::Tool::Response.new([{
+            type: "text",
+            text: "**Error**: Account name must end with '_ACCOUNT'. Example: 'TRADING_BROKERAGE_ACCOUNT'"
+          }])
+        end
+
+        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
+
+          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 = account_mappings.map { |m| "[REDACTED]" }.join(", ")
+            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 ID: #{account_name}")
+
+          log_debug("Fetching account information with fields: #{fields}")
+          account_response = client.get_account(account_hash, fields: fields)
+
+          if account_response&.body
+            log_info("Successfully retrieved account information for #{account_name}")
+            account_data = JSON.parse(account_response.body)
+
+            formatted_response = format_account_data(account_data, account_name, account_id)
+
+            MCP::Tool::Response.new([{
+              type: "text",
+              text: formatted_response
+            }])
+          else
+            log_warn("Empty response from Schwab API for account: #{account_name}")
+            MCP::Tool::Response.new([{
+              type: "text",
+              text: "**No Data**: Empty response from Schwab API for account: #{account_name}"
+            }])
+          end
+
+        rescue JSON::ParserError => e
+          log_error("JSON parsing error: #{e.message}")
+          MCP::Tool::Response.new([{
+            type: "text",
+            text: "**Error**: Failed to parse API response: #{e.message}"
+          }])
+        rescue => e
+          log_error("Error retrieving account information for #{account_name}: #{e.message}")
+          log_debug("Backtrace: #{e.backtrace.first(3).join('\n')}")
+          MCP::Tool::Response.new([{
+            type: "text",
+            text: "**Error** retrieving account information for #{account_name}: #{e.message}\n\n#{e.backtrace.first(3).join('\n')}"
+          }])
+        end
+      end
+
+      private
+
+      def self.format_account_data(account_data, account_name, account_id)
+        account = account_data["securitiesAccount"]
+        friendly_name = account_name.gsub('_ACCOUNT', '').split('_').map(&:capitalize).join(' ')
+
+        formatted = "**Account Information for #{friendly_name} (#{account_name}):**\n\n"
+
+        if account
+          formatted += "**Account Number:** #{Redactor::REDACTED_ACCOUNT_PLACEHOLDER}\n"
+          formatted += "**Account Type:** #{account['type']}\n"
+
+          if current_balances = account['currentBalances']
+            formatted += "\n**Current Balances:**\n"
+            formatted += "- Cash Balance: $#{format_currency(current_balances['cashBalance'])}\n"
+            formatted += "- Buying Power: $#{format_currency(current_balances['buyingPower'])}\n"
+            formatted += "- Total Cash: $#{format_currency(current_balances['totalCash'])}\n"
+            formatted += "- Liquidation Value: $#{format_currency(current_balances['liquidationValue'])}\n"
+            formatted += "- Long Market Value: $#{format_currency(current_balances['longMarketValue'])}\n"
+            formatted += "- Short Market Value: $#{format_currency(current_balances['shortMarketValue'])}\n"
+          end
+
+          # Positions summary
+          if positions = account['positions']
+            formatted += "\n**Positions Summary:**\n"
+            formatted += "- Total Positions: #{positions.length}\n"
+
+            if positions.length > 0
+              formatted += "\n**Position Details:**\n"
+              positions.each do |position|
+                symbol = position.dig('instrument', 'symbol')
+                qty = position['longQuantity'].to_f - position['shortQuantity'].to_f
+                market_value = position['marketValue']
+                formatted += "- #{symbol}: #{qty} shares, Market Value: $#{format_currency(market_value)}\n"
+              end
+            end
+          end
+
+          if orders = account['orderStrategies']
+            formatted += "\n**Active Orders:**\n"
+            formatted += "- Total Orders: #{orders.length}\n"
+
+            orders.each do |order|
+              status = order['status']
+              symbol = order.dig('orderLegCollection', 0, 'instrument', 'symbol')
+              formatted += "- #{symbol}: #{status}\n"
+            end
+          end        end
+
+        redacted_data = Redactor.redact(account_data)
+        formatted += "\n```json\n#{JSON.pretty_generate(redacted_data)}\n```"
+        formatted
+      end
+
+      def self.format_currency(amount)
+        return "0.00" if amount.nil?
+        "%.2f" % amount.to_f
+      end
+    end
+  end
+end
+

data/lib/schwab_mcp/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SchwabMCP
+  VERSION = "0.1.0"
+end

data/lib/schwab_mcp.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "mcp"
+require "mcp/transports/stdio"
+require "tmpdir"
+require "schwab_rb"
+require_relative "schwab_mcp/version"
+require_relative "schwab_mcp/redactor"
+require_relative "schwab_mcp/tools/quote_tool"
+require_relative "schwab_mcp/tools/quotes_tool"
+require_relative "schwab_mcp/tools/option_chain_tool"
+require_relative "schwab_mcp/tools/option_strategy_finder_tool"
+require_relative "schwab_mcp/tools/help_tool"
+require_relative "schwab_mcp/tools/schwab_account_details_tool"
+require_relative "schwab_mcp/tools/list_schwab_accounts_tool"
+require_relative "schwab_mcp/tools/list_account_orders_tool"
+require_relative "schwab_mcp/tools/list_account_transactions_tool"
+require_relative "schwab_mcp/tools/get_order_tool"
+require_relative "schwab_mcp/tools/cancel_order_tool"
+require_relative "schwab_mcp/tools/preview_order_tool"
+require_relative "schwab_mcp/tools/place_order_tool"
+require_relative "schwab_mcp/tools/replace_order_tool"
+require_relative "schwab_mcp/tools/list_movers_tool"
+require_relative "schwab_mcp/tools/get_market_hours_tool"
+require_relative "schwab_mcp/tools/get_price_history_tool"
+require_relative "schwab_mcp/loggable"
+
+
+module SchwabMCP
+  class Error < StandardError; end
+
+  TOOLS = [
+    Tools::QuoteTool,
+    Tools::QuotesTool,
+    Tools::OptionChainTool,
+    Tools::OptionStrategyFinderTool,
+    Tools::HelpTool,
+    Tools::SchwabAccountDetailsTool,
+    Tools::ListSchwabAccountsTool,
+    Tools::ListAccountOrdersTool,
+    Tools::ListAccountTransactionsTool,
+    Tools::GetOrderTool,
+    Tools::CancelOrderTool,
+    Tools::PreviewOrderTool,
+    Tools::PlaceOrderTool,
+    Tools::ReplaceOrderTool,
+    Tools::ListMoversTool,
+    Tools::GetMarketHoursTool,
+    Tools::GetPriceHistoryTool
+  ].freeze
+
+  class Server
+    include Loggable
+
+    def initialize
+      configure_schwab_rb_logging
+
+      @server = MCP::Server.new(
+        name: "schwab_mcp_server",
+        version: SchwabMCP::VERSION,
+        tools: TOOLS,
+      )
+    end
+
+    def start
+      configure_mcp
+      log_info("🚀 Starting Schwab MCP Server #{SchwabMCP::VERSION}")
+      log_info("📊 Available tools: #{TOOLS.map { |tool| tool.name.split('::').last }.join(', ')}")
+      log_info("📝 Logs will be written to: #{log_file_path}")
+      transport = MCP::Transports::StdioTransport.new(@server)
+      transport.open
+    end
+
+    private
+
+    def configure_schwab_rb_logging
+      SchwabRb.configure do |config|
+        config.logger = SchwabMCP::Logger.instance
+        config.log_level = ENV.fetch('LOG_LEVEL', 'INFO').upcase
+      end
+
+      log_info("Configured schwab_rb to use shared logger")
+    end
+
+    def log_file_path
+      if ENV['LOGFILE'] && !ENV['LOGFILE'].empty?
+        ENV['LOGFILE']
+      else
+        File.join(Dir.tmpdir, 'schwab_mcp.log')
+      end
+    end
+
+    def configure_mcp
+      MCP.configure do |config|
+        config.exception_reporter = ->(exception, server_context) do
+          log_error("MCP Error: #{exception.class.name} - #{exception.message}")
+          log_debug(exception.backtrace.first(3).join("\n"))
+        end
+
+        config.instrumentation_callback = ->(data) do
+          duration = data[:duration] ? " - #{data[:duration].round(3)}s" : ""
+          log_debug("MCP: #{data[:method]}#{data[:tool_name] ? " (#{data[:tool_name]})" : ""}#{duration}")
+        end
+      end
+    end
+  end
+end

data/sig/schwab_mcp.rbs

@@ -0,0 +1,4 @@
+module SchwabMCP
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/start_mcp_server.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+cd /Users/jplatta/repos/schwab_mcp
+exec /Users/jplatta/.asdf/shims/bundle exec exe/schwab_mcp