feedback from code review

atproto/client/apierror.go

···
 }
 
 func (ae *APIError) Error() string {
-	if ae.StatusCode > 0 && ae.Name != "" && ae.Message != "" {
-		return fmt.Sprintf("API request failed (HTTP %d): %s: %s", ae.StatusCode, ae.Name, ae.Message)
-	} else if ae.StatusCode > 0 && ae.Name != "" {
-		return fmt.Sprintf("API request failed (HTTP %d): %s", ae.StatusCode, ae.Name)
-	} else if ae.StatusCode > 0 {
+	if ae.StatusCode > 0 {
+		if ae.Name != "" && ae.Message != "" {
+			return fmt.Sprintf("API request failed (HTTP %d): %s: %s", ae.StatusCode, ae.Name, ae.Message)
+		} else if ae.Name != "" {
+			return fmt.Sprintf("API request failed (HTTP %d): %s", ae.StatusCode, ae.Name)
+		}
 		return fmt.Sprintf("API request failed (HTTP %d)", ae.StatusCode)
 	}
 	return "API request failed"

atproto/client/lexclient.go

···
 )
 
 // Implements the [github.com/bluesky-social/indigo/lex/util.LexClient] interface, for use with code-generated API helpers.
-func (c *APIClient) LexDo(ctx context.Context, kind string, inpenc string, method string, params map[string]any, bodyobj any, out any) error {
+func (c *APIClient) LexDo(ctx context.Context, method string, inputEncoding string, endpoint string, params map[string]any, bodyData any, out any) error {
 	// some of the code here is copied from indigo:xrpc/xrpc.go
 
-	nsid, err := syntax.ParseNSID(method)
+	nsid, err := syntax.ParseNSID(endpoint)
 	if err != nil {
 		return err
 	}
 
 	var body io.Reader
-	if bodyobj != nil {
-		if rr, ok := bodyobj.(io.Reader); ok {
+	if bodyData != nil {
+		if rr, ok := bodyData.(io.Reader); ok {
 			body = rr
 		} else {
-			b, err := json.Marshal(bodyobj)
+			b, err := json.Marshal(bodyData)
 			if err != nil {
 				return err
 			}
 
 			body = bytes.NewReader(b)
+			if inputEncoding == "" {
+				inputEncoding = "application/json"
+			}
 		}
 	}
 
-	req := NewAPIRequest(kind, nsid, body)
+	req := NewAPIRequest(method, nsid, body)
 
-	if bodyobj != nil && inpenc != "" {
-		req.Headers.Set("Content-Type", inpenc)
+	if inputEncoding != "" {
+		req.Headers.Set("Content-Type", inputEncoding)
 	}
 
 	if params != nil {

atproto/client/params.go

···
 		case nil:
 			out.Set(k, "")
 		case bool:
-			if v {
-				out.Set(k, "true")
-			} else {
-				out.Set(k, "false")
-			}
+			out.Set(k, fmt.Sprint(v))
 		case string:
 			out.Set(k, v)
-		case int, uint, int8, int16, int32, int64, uint8, uint16, uint32, uint64:
-			out.Set(k, fmt.Sprintf("%d", v))
+		case int, uint, int8, int16, int32, int64, uint8, uint16, uint32, uint64, uintptr:
+			out.Set(k, fmt.Sprint(v))
 		case encoding.TextMarshaler:
-			out.Set(k, fmt.Sprintf("%s", v))
+			out.Set(k, fmt.Sprint(v))
 		default:
 			ref := reflect.ValueOf(v)
 			if ref.Kind() == reflect.Slice {
···
 					case nil:
 						out.Add(k, "")
 					case bool:
-						if elem {
-							out.Add(k, "true")
-						} else {
-							out.Add(k, "false")
-						}
+						out.Add(k, fmt.Sprint(elem))
 					case string:
 						out.Add(k, elem)
-					case int, uint, int8, int16, int32, int64, uint8, uint16, uint32, uint64:
-						out.Add(k, fmt.Sprintf("%d", elem))
+					case int, uint, int8, int16, int32, int64, uint8, uint16, uint32, uint64, uintptr:
+						out.Add(k, fmt.Sprint(elem))
 					case encoding.TextMarshaler:
-						out.Add(k, fmt.Sprintf("%s", elem))
+						out.Add(k, fmt.Sprint(elem))
 					default:
-						return nil, fmt.Errorf("can't marshal query param type: %T", v)
+						return nil, fmt.Errorf("can't marshal query param '%s' with type: %T", k, v)
 					}
 				}
 			} else {
-				return nil, fmt.Errorf("can't marshal query param type: %T", v)
+				return nil, fmt.Errorf("can't marshal query param '%s' with type: %T", k, v)
 			}
 		}
 	}