diff --git a/cmd/mcptools/main.go b/cmd/mcptools/main.go
index 66a2eff..ccbdf3a 100644
--- a/cmd/mcptools/main.go
+++ b/cmd/mcptools/main.go
@@ -50,6 +50,20 @@ var (
 	errCommandRequired = fmt.Errorf("command to execute is required when using stdio transport")
 )
 
+// createClientFunc is the function used to create MCP clients.
+// This can be replaced in tests to use a mock transport.
+var createClientFunc = func(args []string) (*client.Client, error) {
+	if len(args) == 0 {
+		return nil, errCommandRequired
+	}
+
+	if len(args) == 1 && (strings.HasPrefix(args[0], "http://") || strings.HasPrefix(args[0], "https://")) {
+		return client.NewHTTP(args[0]), nil
+	}
+
+	return client.NewStdio(args), nil
+}
+
 func main() {
 	cobra.EnableCommandSorting = false
 
@@ -97,18 +111,6 @@ func newVersionCmd() *cobra.Command {
 	}
 }
 
-func createClient(args []string) (*client.Client, error) {
-	if len(args) == 0 {
-		return nil, errCommandRequired
-	}
-
-	if len(args) == 1 && (strings.HasPrefix(args[0], "http://") || strings.HasPrefix(args[0], "https://")) {
-		return client.NewHTTP(args[0]), nil
-	}
-
-	return client.NewStdio(args), nil
-}
-
 func processFlags(args []string) []string {
 	parsedArgs := []string{}
 
@@ -155,7 +157,7 @@ func newToolsCmd() *cobra.Command {
 
 			parsedArgs := processFlags(args)
 
-			mcpClient, err := createClient(parsedArgs)
+			mcpClient, err := createClientFunc(parsedArgs)
 			if err != nil {
 				fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 				fmt.Fprintf(os.Stderr, "Example: mcp tools npx -y @modelcontextprotocol/server-filesystem ~\n")
@@ -185,7 +187,7 @@ func newResourcesCmd() *cobra.Command {
 
 			parsedArgs := processFlags(args)
 
-			mcpClient, err := createClient(parsedArgs)
+			mcpClient, err := createClientFunc(parsedArgs)
 			if err != nil {
 				fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 				fmt.Fprintf(os.Stderr, "Example: mcp resources npx -y @modelcontextprotocol/server-filesystem ~\n")
@@ -215,7 +217,7 @@ func newPromptsCmd() *cobra.Command {
 
 			parsedArgs := processFlags(args)
 
-			mcpClient, err := createClient(parsedArgs)
+			mcpClient, err := createClientFunc(parsedArgs)
 			if err != nil {
 				fmt.Fprintf(os.Stderr, "Error: %v\n", err)
 				fmt.Fprintf(os.Stderr, "Example: mcp prompts npx -y @modelcontextprotocol/server-filesystem ~\n")
@@ -311,7 +313,7 @@ func newCallCmd() *cobra.Command {
 				}
 			}
 
-			mcpClient, clientErr := createClient(parsedArgs)
+			mcpClient, clientErr := createClientFunc(parsedArgs)
 			if clientErr != nil {
 				fmt.Fprintf(os.Stderr, "Error: %v\n", clientErr)
 				os.Exit(1)
@@ -403,7 +405,7 @@ func newGetPromptCmd() *cobra.Command {
 				}
 			}
 
-			mcpClient, clientErr := createClient(parsedArgs)
+			mcpClient, clientErr := createClientFunc(parsedArgs)
 			if clientErr != nil {
 				fmt.Fprintf(os.Stderr, "Error: %v\n", clientErr)
 				os.Exit(1)
@@ -481,7 +483,7 @@ func newReadResourceCmd() *cobra.Command {
 				}
 			}
 
-			mcpClient, clientErr := createClient(parsedArgs)
+			mcpClient, clientErr := createClientFunc(parsedArgs)
 			if clientErr != nil {
 				fmt.Fprintf(os.Stderr, "Error: %v\n", clientErr)
 				os.Exit(1)
@@ -529,7 +531,7 @@ func newShellCmd() *cobra.Command { //nolint:gocyclo
 				os.Exit(1)
 			}
 
-			mcpClient, clientErr := createClient(parsedArgs)
+			mcpClient, clientErr := createClientFunc(parsedArgs)
 			if clientErr != nil {
 				fmt.Fprintf(os.Stderr, "Error: %v\n", clientErr)
 				os.Exit(1)
@@ -850,7 +852,7 @@ Available types:
 - prompt <name> <description> <template>
 - resource <uri> <description> <content>
 
-Example: 
+Example:
   mcp mock tool hello_world "when user says hello world, run this tool"
   mcp mock tool hello_world "A greeting tool" \
          prompt welcome "A welcome prompt" "Hello {{name}}, welcome to {{location}}!" \
@@ -1040,9 +1042,47 @@ Example with script:
   mcp proxy tool add_operation "Adds a and b" "a:int,b:int" ./add.sh
 
 Example with inline command:
-  mcp proxy tool add_op "Adds given numbers" "a:int,b:int" -e "echo \"total is $a + $b = ${$a+$b}\""`,
-		Args: cobra.RangeArgs(3, 4),
+  mcp proxy tool add_op "Adds given numbers" "a:int,b:int" -e "echo \"total is $a + $b = ${$a+$b}\""
+
+To unregister a tool, use the --unregister flag:
+  mcp proxy tool --unregister tool_name`,
+		Args: func(cmd *cobra.Command, args []string) error {
+			unregister, _ := cmd.Flags().GetBool("unregister")
+			if unregister {
+				if len(args) != 1 {
+					return fmt.Errorf("unregister requires exactly one argument: the tool name")
+				}
+				return nil
+			}
+			return cobra.RangeArgs(3, 4)(cmd, args)
+		},
 		RunE: func(cmd *cobra.Command, args []string) error {
+			unregister, _ := cmd.Flags().GetBool("unregister")
+			if unregister {
+				name := args[0]
+				// Load existing config
+				config, loadErr := loadProxyConfig()
+				if loadErr != nil {
+					return fmt.Errorf("error loading config: %w", loadErr)
+				}
+
+				// Check if tool exists
+				if _, exists := config[name]; !exists {
+					return fmt.Errorf("tool %s not found", name)
+				}
+
+				// Remove the tool from config
+				delete(config, name)
+
+				// Save updated config
+				if saveErr := saveProxyConfig(config); saveErr != nil {
+					return fmt.Errorf("error saving config: %w", saveErr)
+				}
+
+				fmt.Printf("Unregistered tool: %s\n", name)
+				return nil
+			}
+
 			name := args[0]
 			description := args[1]
 			parameters := args[2]
@@ -1084,6 +1124,7 @@ Example with inline command:
 	}
 
 	cmd.Flags().StringP("execute", "e", "", "Inline command to execute instead of a script file")
+	cmd.Flags().Bool("unregister", false, "Unregister a tool")
 	return cmd
 }
 
@@ -1113,7 +1154,7 @@ Example:
 			}
 
 			// Run proxy server
-			fmt.Println("Starting proxy server...")
+			fmt.Fprintln(os.Stderr, "Starting proxy server...")
 			if err := proxy.RunProxyServer(config); err != nil {
 				log.Fatalf("Error running proxy server: %v", err)
 			}
diff --git a/cmd/mcptools/main_test.go b/cmd/mcptools/main_test.go
index 6eae940..129deed 100644
--- a/cmd/mcptools/main_test.go
+++ b/cmd/mcptools/main_test.go
@@ -6,9 +6,12 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"os"
+	"path/filepath"
 	"strings"
 	"testing"
 
+	"github.com/f/mcptools/pkg/client"
 	"github.com/f/mcptools/pkg/transport"
 )
 
@@ -93,38 +96,6 @@ func (t *MockTransport) Execute(method string, params interface{}) (map[string]i
 	return map[string]interface{}{}, fmt.Errorf("unknown method: %s", method)
 }
 
-// func setupTestCommand() (*cobra.Command, *bytes.Buffer) {
-// 	outBuf := &bytes.Buffer{}
-//
-// 	rootCmd := &cobra.Command{
-// 		Use:   "mcp",
-// 		Short: "MCP CLI",
-// 	}
-//
-// 	shellCmd := &cobra.Command{
-// 		Use:   "shell",
-// 		Short: "Interactive shell",
-// 		Run: func(cmd *cobra.Command, args []string) {
-// 			mockTransport := NewMockTransport()
-//
-// 			shell := &Shell{
-// 				Transport: mockTransport,
-// 				Format:    "table",
-// 				Reader: strings.NewReader(
-// 					"tools\ncall test_tool --params '{\"foo\":\"bar\"}'\ntest_tool {\"foo\":\"bar\"}\nresource:test_resource\nprompt:test_prompt\n/q\n",
-// 				),
-// 				Writer: outBuf,
-// 			}
-//
-// 			shell.Run()
-// 		},
-// 	}
-//
-// 	rootCmd.AddCommand(shellCmd)
-//
-// 	return rootCmd, outBuf
-// }
-
 type Shell struct {
 	Transport transport.Transport
 	Reader    io.Reader
@@ -348,3 +319,219 @@ func TestExecuteShell(t *testing.T) {
 		}
 	}
 }
+
+func TestProxyToolRegistration(t *testing.T) {
+	// Create a temporary directory for test files
+	tmpDir := t.TempDir()
+	os.Setenv("HOME", tmpDir)
+
+	// Test cases
+	testCases := []struct {
+		name        string
+		args        []string
+		expectError bool
+	}{
+		{
+			name: "register with script",
+			args: []string{
+				"add_numbers",
+				"Adds two numbers",
+				"a:int,b:int",
+				filepath.Join(tmpDir, "add.sh"),
+			},
+			expectError: false,
+		},
+		{
+			name: "register with inline command",
+			args: []string{
+				"add_op",
+				"Adds given numbers",
+				"a:int,b:int",
+				"-e",
+				"echo \"$a + $b = $(($a+$b))\"",
+			},
+			expectError: false,
+		},
+		{
+			name: "register without script or command",
+			args: []string{
+				"invalid",
+				"Invalid tool",
+				"x:int",
+			},
+			expectError: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			cmd := proxyToolCmd()
+			err := cmd.RunE(cmd, tc.args)
+
+			if tc.expectError {
+				if err == nil {
+					t.Error("Expected error but got none")
+				}
+				return
+			}
+
+			if err != nil {
+				t.Errorf("Unexpected error: %v", err)
+				return
+			}
+
+			// Verify the tool was registered in the config
+			config, err := loadProxyConfig()
+			if err != nil {
+				t.Fatalf("Error loading config: %v", err)
+			}
+
+			toolName := tc.args[0]
+			if _, exists := config[toolName]; !exists {
+				t.Errorf("Tool %s was not registered in config", toolName)
+			}
+		})
+	}
+}
+
+func TestProxyToolUnregistration(t *testing.T) {
+	// Create a temporary directory for test files
+	tmpDir := t.TempDir()
+	os.Setenv("HOME", tmpDir)
+
+	// First register a tool
+	cmd := proxyToolCmd()
+	err := cmd.RunE(cmd, []string{
+		"test_tool",
+		"Test tool",
+		"x:int",
+		"-e",
+		"echo $x",
+	})
+	if err != nil {
+		t.Fatalf("Error registering tool: %v", err)
+	}
+
+	// Now try to unregister it
+	cmd.Flags().Set("unregister", "true")
+	err = cmd.RunE(cmd, []string{"test_tool"})
+	if err != nil {
+		t.Errorf("Error unregistering tool: %v", err)
+	}
+
+	// Verify the tool was removed from the config
+	config, err := loadProxyConfig()
+	if err != nil {
+		t.Fatalf("Error loading config: %v", err)
+	}
+
+	if _, exists := config["test_tool"]; exists {
+		t.Error("Tool was not unregistered from config")
+	}
+}
+
+// testCreateClient is a test-specific version of createClient that always returns a client with our mock transport
+var testCreateClient func(args []string) (*client.Client, error)
+
+func TestShellCommands(t *testing.T) {
+	// Create a mock server for testing
+	mockServer := NewMockTransport()
+	mockServer.Responses = map[string]map[string]interface{}{
+		"tools/list": {
+			"tools": []map[string]interface{}{
+				{
+					"name":        "test_tool",
+					"description": "A test tool",
+				},
+			},
+		},
+		"tools/call": {
+			"result": "Called test_tool",
+		},
+		"resources/list": {
+			"resources": []map[string]interface{}{
+				{
+					"uri":         "test_resource",
+					"description": "A test resource",
+				},
+			},
+		},
+		"resources/read": {
+			"content": "Resource content",
+		},
+		"prompts/list": {
+			"prompts": []map[string]interface{}{
+				{
+					"name":        "test_prompt",
+					"description": "A test prompt",
+				},
+			},
+		},
+		"prompts/get": {
+			"content": "Prompt content",
+		},
+	}
+
+	// Test cases
+	testCases := []struct {
+		name           string
+		input          string
+		expectedOutput string
+	}{
+		{
+			name:           "list tools",
+			input:          "tools\n/q\n",
+			expectedOutput: "test_tool",
+		},
+		{
+			name:           "list resources",
+			input:          "resources\n/q\n",
+			expectedOutput: "test_resource",
+		},
+		{
+			name:           "list prompts",
+			input:          "prompts\n/q\n",
+			expectedOutput: "test_prompt",
+		},
+		{
+			name:           "call tool with params",
+			input:          "call test_tool --params {\"foo\":\"bar\"}\n/q\n",
+			expectedOutput: "Called test_tool",
+		},
+		{
+			name:           "direct tool call",
+			input:          "test_tool {\"foo\":\"bar\"}\n/q\n",
+			expectedOutput: "Called test_tool",
+		},
+		{
+			name:           "read resource",
+			input:          "resource:test_resource\n/q\n",
+			expectedOutput: "Resource content",
+		},
+		{
+			name:           "get prompt",
+			input:          "prompt:test_prompt\n/q\n",
+			expectedOutput: "Prompt content",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			outBuf := &bytes.Buffer{}
+
+			shell := &Shell{
+				Transport: mockServer,
+				Format:    "table",
+				Reader:    strings.NewReader(tc.input),
+				Writer:    outBuf,
+			}
+
+			shell.Run()
+
+			output := outBuf.String()
+			if !strings.Contains(output, tc.expectedOutput) {
+				t.Errorf("Expected output to contain %q, got: %s", tc.expectedOutput, output)
+			}
+		})
+	}
+}
diff --git a/pkg/proxy/proxy.go b/pkg/proxy/proxy.go
index c3254eb..529f4d3 100644
--- a/pkg/proxy/proxy.go
+++ b/pkg/proxy/proxy.go
@@ -319,9 +319,9 @@ func (s *Server) Start() error {
 		if err := decoder.Decode(&request); err != nil {
 			if err == io.EOF {
 				s.log("Client disconnected (EOF)")
-			} else {
-				s.log(fmt.Sprintf("Error decoding request: %v", err))
+				return nil
 			}
+			s.log(fmt.Sprintf("Error decoding request: %v", err))
 			fmt.Fprintf(os.Stderr, "Error decoding request: %v\n", err)
 			return fmt.Errorf("error decoding request: %w", err)
 		}
@@ -568,9 +568,9 @@ func RunProxyServer(toolConfigs map[string]map[string]string) error {
 	}
 
 	// Print registered tools
-	fmt.Println("Registered proxy tools:")
+	fmt.Fprintln(os.Stderr, "Registered proxy tools:")
 	for name, tool := range server.tools {
-		fmt.Printf("- %s: %s (script: %s)\n", name, tool.Description, tool.ScriptPath)
+		fmt.Fprintf(os.Stderr, "- %s: %s (script: %s)\n", name, tool.Description, tool.ScriptPath)
 		paramStr := ""
 		for i, param := range tool.Parameters {
 			if i > 0 {
@@ -579,7 +579,7 @@ func RunProxyServer(toolConfigs map[string]map[string]string) error {
 			paramStr += param.Name + ":" + param.Type
 		}
 		if paramStr != "" {
-			fmt.Printf("  Parameters: %s\n", paramStr)
+			fmt.Fprintf(os.Stderr, "  Parameters: %s\n", paramStr)
 		}
 	}