schwab_mcp 0.2.0 → 0.3.0

data/lib/schwab_mcp/tools/place_order_tool.rb

@@ -19,7 +19,7 @@ module SchwabMCP
           },
           strategy_type: {
             type: "string",
-            enum: %w[single ironcondor vertical],
+            enum: %w[SINGLE VERTICAL IRON_CONDOR],
             description: "Type of options strategy to place"
           },
           price: {
@@ -101,11 +101,8 @@ module SchwabMCP
           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 = 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,
@@ -123,7 +120,7 @@ module SchwabMCP
           )
 
           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})")
@@ -157,77 +154,62 @@ module SchwabMCP
       end
 
       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 = client.get_account_numbers
-
-        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"
-                                         }])
-        end
-
-        log_debug("Account mappings retrieved (#{account_numbers.size} accounts found)")
-
-        account_hash = account_numbers.find_hash_value(account_id)
-
-        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_numbers.size} accounts available."
+                                           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"
+        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(", ")}"
           end
-        when "callspread", "putspread"
+        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(", ")}"
           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]}"
         end
       end
 
       def self.format_place_order_response(response, params)
-        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
+        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(" ")
 

data/lib/schwab_mcp/tools/preview_order_tool.rb

@@ -20,7 +20,7 @@ module SchwabMCP
           },
           strategy_type: {
             type: "string",
-            enum: ["ironcondor", "vertical", "single"],
+            enum: %w[SINGLE VERTICAL IRON_CONDOR],
             description: "Type of options strategy to preview"
           },
           price: {
@@ -106,11 +106,8 @@ module SchwabMCP
           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 = 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,
@@ -124,11 +121,11 @@ module SchwabMCP
             short_leg_symbol: params[:short_leg_symbol],
             long_leg_symbol: params[:long_leg_symbol],
             # Single option params
-            symbol: params[:symbol],
+            symbol: params[:symbol]
           )
 
           log_debug("Making preview order API request")
-          response = client.preview_order(account_hash, order_builder, return_data_objects: true)
+          response = client.preview_order(account_name: params[:account_name], order: order_builder, return_data_objects: true)
 
           if response
             log_info("Successfully previewed #{params[:strategy_type]} order")
@@ -159,59 +156,36 @@ 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")
-          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: 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 = 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: Redactor.redact_formatted_text(error_msg)
-          }])
-        end
-
-        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."
+        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: Redactor.redact_formatted_text(error_msg)
           }])
         end
 
-        log_debug("Found account hash for account name: #{account_name}")
-        [account_id, mapping.hash_value]
+        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 'vertical'
+        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'
+        when 'SINGLE'
           required_fields = [:symbol]
           missing_fields = required_fields.select { |field| params[field].nil? || params[field].empty? }
           unless missing_fields.empty?
@@ -222,58 +196,22 @@ module SchwabMCP
         end
       end
 
-      def self.format_preview_response(response_body, params)
-        parsed = JSON.parse(response_body)
-        redacted_data = Redactor.redact(parsed)
-
-        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"
-
-          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```"
-        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'
+          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 'vertical'
-            "**Vertical Preview**\n" \
+          when 'VERTICAL'
+            "**Vertical Spread Preview**\n" \
             "- Short Leg: #{params[:short_leg_symbol]}\n" \
             "- Long Leg: #{params[:long_leg_symbol]}\n"
-          when 'single'
+          when 'SINGLE'
             "**Single Option Preview**\n" \
             "- Symbol: #{params[:symbol]}\n"
           end

data/lib/schwab_mcp/tools/quote_tool.rb

@@ -16,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"]
@@ -38,7 +38,7 @@ module SchwabMCP
           return SchwabClientFactory.client_error_response unless client
 
           log_debug("Making API request for symbol: #{symbol}")
-          quote_obj = client.get_quote(symbol.upcase, return_data_objects: true)
+          quote_obj = client.get_quote(symbol.upcase)
 
           unless quote_obj
             log_warn("No quote data object returned for symbol: #{symbol}")
@@ -48,7 +48,6 @@ module SchwabMCP
             }])
           end
 
-          # Format output based on quote type
           formatted = format_quote_object(quote_obj)
           log_info("Successfully retrieved quote for #{symbol}")
           MCP::Tool::Response.new([{
@@ -66,7 +65,6 @@ module SchwabMCP
         end
       end
 
-      # Format the quote object for display
       def self.format_quote_object(obj)
         case obj
         when SchwabRb::DataObjects::OptionQuote

data/lib/schwab_mcp/tools/replace_order_tool.rb

@@ -23,7 +23,7 @@ module SchwabMCP
           },
           strategy_type: {
             type: "string",
-            enum: %w[ironcondor callspread putspread],
+            enum: %w[SINGLE VERTICAL IRON_CONDOR],
             description: "Type of options strategy for the replacement order"
           },
           price: {
@@ -105,11 +105,8 @@ module SchwabMCP
           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 = 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,
@@ -127,7 +124,7 @@ module SchwabMCP
           )
 
           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})")
@@ -161,77 +158,62 @@ module SchwabMCP
       end
 
       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 = client.get_account_numbers
-
-        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"
-                                         }])
-        end
-
-        log_debug("Account mappings retrieved (#{account_numbers.size} accounts found)")
-
-        account_hash = account_numbers.find_hash_value(account_id)
-
-        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_numbers.size} accounts available."
+                                           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"
+        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(", ")}"
           end
-        when "callspread", "putspread"
+        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(", ")}"
           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]}"
         end
       end
 
       def self.format_replace_order_response(response, params)
-        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
+        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(" ")
 

data/lib/schwab_mcp/tools/schwab_account_details_tool.rb

@@ -51,50 +51,24 @@ module SchwabMCP
           client = SchwabClientFactory.create_client
           return SchwabClientFactory.client_error_response unless client
 
-          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."
+              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 = client.get_account_numbers
-
-          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"
-            }])
-          end
-
-          log_debug("Account numbers retrieved (#{account_numbers.size} accounts found)")
-
-          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_numbers.size} accounts available."
-            }])
-          end
-
-          log_debug("Found account hash for account ID: #{account_name}")
+          log_debug("Using account name: #{account_name}")
           log_debug("Fetching account information with fields: #{fields}")
 
-          account = client.get_account(account_hash, fields: fields)
+          account = client.get_account(account_name: account_name, fields: fields)
 
           if account
             log_info("Successfully retrieved account information for #{account_name}")
 
-            formatted_response = format_account_data(account, account_name, account_id)
+            formatted_response = format_account_data(account, account_name)
 
             MCP::Tool::Response.new([{
               type: "text",
@@ -126,7 +100,7 @@ module SchwabMCP
 
       private
 
-      def self.format_account_data(account, account_name, account_id)
+      def self.format_account_data(account, account_name)
         friendly_name = account_name.gsub('_ACCOUNT', '').split('_').map(&:capitalize).join(' ')
 
         formatted = "**Account Information for #{friendly_name} (#{account_name}):**\n\n"

data/lib/schwab_mcp/version.rb

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

data/lib/schwab_mcp.rb

@@ -11,7 +11,6 @@ require_relative "schwab_mcp/tools/quotes_tool"
 require_relative "schwab_mcp/tools/option_chain_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"
@@ -22,6 +21,7 @@ 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/tools/get_account_names_tool"
 require_relative "schwab_mcp/loggable"
 require_relative "schwab_mcp/schwab_client_factory"
 
@@ -35,7 +35,6 @@ module SchwabMCP
     Tools::OptionChainTool,
     Tools::HelpTool,
     Tools::SchwabAccountDetailsTool,
-    Tools::ListSchwabAccountsTool,
     Tools::ListAccountOrdersTool,
     Tools::ListAccountTransactionsTool,
     Tools::GetOrderTool,
@@ -45,35 +44,38 @@ module SchwabMCP
     Tools::ReplaceOrderTool,
     Tools::ListMoversTool,
     Tools::GetMarketHoursTool,
-    Tools::GetPriceHistoryTool
+    Tools::GetPriceHistoryTool,
+    Tools::GetAccountNamesTool
   ].freeze
 
   class Server
     include Loggable
 
     def initialize
-      configure_schwab_rb_logging
+      configure_schwab_rb
 
       @server = MCP::Server.new(
         name: "schwab_mcp_server",
         version: SchwabMCP::VERSION,
         tools: TOOLS,
+        server_context: { user: "foobar" }
       )
     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}")
+      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
+    def configure_schwab_rb
       SchwabRb.configure do |config|
+        config.schwab_home = ENV['SCHWAB_HOME']
         config.logger = SchwabMCP::Logger.instance
         config.log_level = ENV.fetch('LOG_LEVEL', 'INFO').upcase
       end